f2f0e1b refactor(ports): declare every cross-layer contract and its types in ports · ermite

M .hexcheck.yaml +4 -2

     role: ignore
     paths:
       - internal/readertest/**
+# Cross-layer contracts live in ports: adapters and app import ports and domain,
+# never each other. hexcheck has no rule for an adapter importing app (only the
+# reverse, no-infra-imports-in-usecase), so that direction is kept by review.
 rules:
   no-adapter-imports-in-core: error
   no-infra-imports-in-usecase: error
 mocking:
   generatedMockPaths:
     - internal/ports/mocks/**
-    - internal/app/mocks/**
+    - internal/adapters/web/mocks/**
-    - internal/adapters/*/mocks/**
   generatedMockNamePatterns:
     - '{{Interface}}'
 allow:

M .mockery.yml +3 -10

-# Mocks of the ports and of the consumer-side interfaces of the adapters and
+# Mocks of the ports, generated in internal/ports/mocks, and of the generated
-# the use cases. Regenerate with: go generate ./internal/ports
+# Connect clients the web adapter calls. Regenerate with:
+# go generate ./internal/ports
 template: testify
 _anchors:
   mocks: &mocks
 packages:
   bnema.dev/ermite/internal/ports:
     config: *mocks
-  bnema.dev/ermite/internal/adapters/githttp:
-    config: *mocks
-  bnema.dev/ermite/internal/adapters/rpc:
-    config: *mocks
-  bnema.dev/ermite/internal/app:
-    config: *mocks
-  bnema.dev/ermite/internal/adapters/web:
-    config: *mocks
   bnema.dev/ermite-api/gen/ermite/ermiteconnect:
     config:
       include-auto-generated: true

M cmd/ermite/api_helpers_test.go +2 -2

 	pb "bnema.dev/ermite-api/gen/ermite"
 	"bnema.dev/ermite-api/gen/ermite/ermiteconnect"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // clients are the generated Connect clients of one caller.
 // commit per file to its main branch with git.
 func (h *harness) seed(name string, vis domain.Visibility, files ...string) {
 	h.t.Helper()
-	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), app.CreateParams{Name: h.name(name), Visibility: vis})
+	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), ports.CreateRepoParams{Name: h.name(name), Visibility: vis})
 	require.NoError(h.t, err)
 	if len(files) == 0 {
 		return

M cmd/ermite/api_test.go +3 -3

 	pb "bnema.dev/ermite-api/gen/ermite"
 	"bnema.dev/ermite/internal/adapters/rpc"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/clientlimit"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // principals of the access tables.
 	}
 }
-func createParams(h *harness, name string, vis domain.Visibility) app.CreateParams {
+func createParams(h *harness, name string, vis domain.Visibility) ports.CreateRepoParams {
-	return app.CreateParams{Name: h.name(name), Visibility: vis}
+	return ports.CreateRepoParams{Name: h.name(name), Visibility: vis}
 }
 // TestUpdateRepoDefaultBranch: HEAD moves with git symbolic-ref once the

M cmd/ermite/e2e_helpers_test.go +2 -2

 	"github.com/bnema/zerowrap"
 	"github.com/stretchr/testify/require"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/config"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // harness is a forge wired like `ermite serve`, behind an httptest server,
 // token creates a stored token through the use case, as root.
 func (h *harness) token(scopes []domain.Scope, repos ...string) string {
 	h.t.Helper()
-	p := app.CreateTokenParams{Label: "e2e", Scopes: scopes}
+	p := ports.CreateTokenParams{Label: "e2e", Scopes: scopes}
 	for _, r := range repos {
 		p.Repos = append(p.Repos, h.name(r))
 	}

M cmd/ermite/e2e_test.go +8 -8

 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 func scopes(s ...domain.Scope) []domain.Scope { return s }
 // publicRepo creates a public repository with one commit pushed by root.
 func (h *harness) publicRepo(name string, files ...string) {
 	h.t.Helper()
-	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), app.CreateParams{Name: h.name(name), Visibility: domain.VisibilityPublic})
+	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), ports.CreateRepoParams{Name: h.name(name), Visibility: domain.VisibilityPublic})
 	require.NoError(h.t, err)
 	wt := h.workTree("main", files...)
 	h.mustGit(wt, "push", "-q", h.urlAuth(adminToken, "/"+name+".git"), "main")
 	assert.Contains(t, out, "Authentication failed")
 	// Revoked token.
-	created, err := h.forge.Tokens.Create(h.ctx, domain.Root(), app.CreateTokenParams{Label: "short", Scopes: scopes(domain.ScopeRepoWrite)})
+	created, err := h.forge.Tokens.Create(h.ctx, domain.Root(), ports.CreateTokenParams{Label: "short", Scopes: scopes(domain.ScopeRepoWrite)})
 	require.NoError(t, err)
 	next("before-revoke")
 	out, err = h.git(wt, "push", "-q", h.urlAuth(created.Secret, "/proj.git"), "main")
 	h := newHarness(t, harnessOpts{})
 	ctx := context.Background()
-	admin, err := h.forge.Tokens.Create(ctx, domain.Root(), app.CreateTokenParams{
+	admin, err := h.forge.Tokens.Create(ctx, domain.Root(), ports.CreateTokenParams{
 		Label: "limited admin", Scopes: scopes(domain.ScopeTokenAdmin, domain.ScopeRepoWrite), Repos: []domain.RepoName{h.name("a")},
 	})
 	require.NoError(t, err)
 	p, err := h.forge.Auth.Authenticate(ctx, admin.Secret)
 	require.NoError(t, err)
-	_, err = h.forge.Tokens.Create(ctx, p, app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoAdmin), Repos: []domain.RepoName{h.name("a")}})
+	_, err = h.forge.Tokens.Create(ctx, p, ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoAdmin), Repos: []domain.RepoName{h.name("a")}})
 	assert.ErrorIs(t, err, domain.ErrForbidden, "scope escalation")
-	_, err = h.forge.Tokens.Create(ctx, p, app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoWrite)})
+	_, err = h.forge.Tokens.Create(ctx, p, ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoWrite)})
 	assert.ErrorIs(t, err, domain.ErrForbidden, "repository list escalation")
-	_, err = h.forge.Tokens.Create(ctx, p, app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoWrite), Repos: []domain.RepoName{h.name("b")}})
+	_, err = h.forge.Tokens.Create(ctx, p, ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoWrite), Repos: []domain.RepoName{h.name("b")}})
 	assert.ErrorIs(t, err, domain.ErrForbidden, "another repository")
-	child, err := h.forge.Tokens.Create(ctx, p, app.CreateTokenParams{Label: "child", Scopes: scopes(domain.ScopeRepoWrite), Repos: []domain.RepoName{h.name("a")}})
+	child, err := h.forge.Tokens.Create(ctx, p, ports.CreateTokenParams{Label: "child", Scopes: scopes(domain.ScopeRepoWrite), Repos: []domain.RepoName{h.name("a")}})
 	require.NoError(t, err)
 	// The child works on its repository, and revoking the index entry kills it at once.

M cmd/ermite/events_test.go +4 -3

 	"bnema.dev/ermite/internal/adapters/rpc"
 	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // watchWait is how long a test waits for an event that must arrive. Only
 		assert.Equal(t, "pub", ev.GetPushed().GetRepo(), name)
 	}
 	// Nothing about priv came before the sentinel, for either of them.
-	_, err = h.forge.Repos.Create(h.ctx, domain.Root(), app.CreateParams{Name: h.name("sentinel"), Visibility: domain.VisibilityPublic})
+	_, err = h.forge.Repos.Create(h.ctx, domain.Root(), ports.CreateRepoParams{Name: h.name("sentinel"), Visibility: domain.VisibilityPublic})
 	require.NoError(t, err)
 	for name, w := range map[string]*stream{"anonymous": anon, "scoped": scoped} {
 		assert.Equal(t, "sentinel", w.next(t, watchWait).GetRepoCreated().GetRepo().GetName(), name)
 func TestWatchEndsWhenTheTokenIsRevoked(t *testing.T) {
 	h := newHarness(t, harnessOpts{revalidateEvery: 20 * time.Millisecond})
 	h.seed("priv", domain.VisibilityPrivate)
-	created, err := h.forge.Tokens.Create(h.ctx, domain.Root(), app.CreateTokenParams{
+	created, err := h.forge.Tokens.Create(h.ctx, domain.Root(), ports.CreateTokenParams{
 		Label: "watcher", Scopes: scopes(domain.ScopeRepoRead),
 	})
 	require.NoError(t, err)
 // order they were published.
 func (h *harness) sentinel(t *testing.T, s *stream, name string) {
 	t.Helper()
-	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), app.CreateParams{Name: h.name(name), Visibility: domain.VisibilityPublic})
+	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), ports.CreateRepoParams{Name: h.name(name), Visibility: domain.VisibilityPublic})
 	require.NoError(t, err)
 	ev := s.next(t, watchWait)
 	assert.Equal(t, name, ev.GetRepoCreated().GetRepo().GetName(), "an event came before the sentinel: %v", ev)

M cmd/ermite/gitreader_test.go +2 -2

 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/config"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // The suite runs with the reader of ERMITE_GIT_READER (ermite-git by default).
 	assert.Equal(t, want, h.forge.cfg.GitReader)
 	assert.Equal(t, want == config.GitReaderErmiteGit, h.forge.reader != nil, "the ermite-git adapter exists only for ermite-git")
-	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), app.CreateParams{
+	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), ports.CreateRepoParams{
 		Name: h.name("fresh"), Visibility: domain.VisibilityPublic,
 	})
 	require.NoError(t, err)

M cmd/ermite/web.go +8 -5

 	"bnema.dev/ermite/internal/clientlimit"
 	"bnema.dev/ermite/internal/config"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // newWeb builds the web pages on the API of this process: the generated
 			"requests and one budget of failed authentications; set it to the proxy networks")
 }
-// webSessions adapts the session use cases to web.SessionAuth: a valid token
+// webSessions adapts the session use cases to ports.WebSessionService: a valid
-// gives the context of the owner, whose principal the API calls of the page
+// token gives the context of the owner, whose principal the API calls of the
-// carry (rpc.API.InProcessClient).
+// page carry (rpc.API.InProcessClient).
 type webSessions struct{ *app.Sessions }
+var _ ports.WebSessionService = webSessions{}
 func (s webSessions) Login(ctx context.Context, nonce string) (string, time.Duration, error) {
 	token, expiresAt, err := s.Sessions.Login(ctx, nonce)
 	if errors.Is(err, domain.ErrUnauthenticated) {
-		return "", 0, web.ErrLinkRejected
+		return "", 0, ports.ErrLinkRejected
 	}
 	if err != nil {
 		return "", 0, err
 		lifetime = d.Round(time.Second)
 	}
 	if lifetime < time.Second {
-		return "", 0, web.ErrLinkRejected
+		return "", 0, ports.ErrLinkRejected
 	}
 	return token, lifetime, nil
 }

M cmd/ermite/web_commits_test.go +2 -2

 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // diffFixture is the repository of the commit pages: one commit for each
 // createRepo creates a public repository for the pages.
 func (h *harness) createRepo(name string, vis domain.Visibility) {
 	h.t.Helper()
-	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), app.CreateParams{Name: h.name(name), Description: "Diffs", Visibility: vis})
+	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), ports.CreateRepoParams{Name: h.name(name), Description: "Diffs", Visibility: vis})
 	require.NoError(h.t, err)
 }

M cmd/ermite/web_events_test.go +5 -4

 	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // sseEvent is one event read from /-/events.
 	assert.Contains(t, ev.data, `href="/pub"`)
 	// A new repository is a row; so is a repository created by a push.
-	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), app.CreateParams{Name: h.name("fresh"), Description: "a <b>fresh</b> one", Visibility: domain.VisibilityPublic})
+	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), ports.CreateRepoParams{Name: h.name("fresh"), Description: "a <b>fresh</b> one", Visibility: domain.VisibilityPublic})
 	require.NoError(t, err)
 	ev = s.next(t, watchWait)
 	assert.Equal(t, "home-list", ev.name)
 	// A repository that turns private is removed from the anonymous list.
 	priv := domain.VisibilityPrivate
-	_, err = h.forge.Repos.Update(h.ctx, domain.Root(), h.name("fresh"), app.UpdateParams{Visibility: &priv})
+	_, err = h.forge.Repos.Update(h.ctx, domain.Root(), h.name("fresh"), ports.UpdateRepoParams{Visibility: &priv})
 	require.NoError(t, err)
 	ev = s.next(t, watchWait)
 	assert.Equal(t, "home-list", ev.name)
 	wt := h.workTree("main", "a.txt")
 	h.mustGit(wt, "push", "-q", h.urlAuth(adminToken, "/priv.git"), "main")
 	desc := "secret change"
-	_, err := h.forge.Repos.Update(h.ctx, domain.Root(), h.name("priv"), app.UpdateParams{Description: &desc})
+	_, err := h.forge.Repos.Update(h.ctx, domain.Root(), h.name("priv"), ports.UpdateRepoParams{Description: &desc})
 	require.NoError(t, err)
 	// Made public later, it does not reveal what happened while it was
 	// private; the update that makes it public is shown.
 // public repository and requires its row to be the next event.
 func (h *harness) sentinelSSE(t *testing.T, s *sseStream, name string) {
 	t.Helper()
-	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), app.CreateParams{Name: h.name(name), Visibility: domain.VisibilityPublic})
+	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), ports.CreateRepoParams{Name: h.name(name), Visibility: domain.VisibilityPublic})
 	require.NoError(t, err)
 	ev := s.next(t, watchWait)
 	assert.Contains(t, ev.data, `id="repo-`+name+`"`, "an event came before the sentinel: %s", ev.data)

M cmd/ermite/web_files_test.go +2 -2

 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // Trojan Source: a right-to-left override and an isolate around code.
 // tag with a slash.
 func (h *harness) webFilesRepo(name string) {
 	h.t.Helper()
-	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), app.CreateParams{
+	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), ports.CreateRepoParams{
 		Name: h.name(name), Description: "Files of every kind", Visibility: domain.VisibilityPublic,
 	})
 	require.NoError(h.t, err)

M cmd/ermite/web_mr_test.go +2 -2

 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // mrRepo is a public repository "proj" with README.md on main and a branch
 	token := r.signIn(t)
 	r.cli(t, adminToken, "mr", "create", "proj", "--source", "feat/search", "--title", "t").ok(t)
 	for i := 0; i < 1000; i++ {
-		_, err := r.forge.MergeRequests.AddComment(r.ctx, domain.Root(), r.name("proj"), 1, app.AddCommentParams{Text: "n"})
+		_, err := r.forge.MergeRequests.AddComment(r.ctx, domain.Root(), r.name("proj"), 1, ports.AddCommentParams{Text: "n"})
 		require.NoError(t, err)
 	}
 	full := b.form("/proj/merge-requests/1/comments", token, url.Values{"text": {"one more"}})

M cmd/ermite/web_session_test.go +2 -2

 	"github.com/stretchr/testify/require"
 	pb "bnema.dev/ermite-api/gen/ermite"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 const (
 	// The cap: a link made by a token that expires in an hour gives a cookie,
 	// and a session, of an hour.
-	soon, err := c.forge.Tokens.Create(c.ctx, domain.Root(), app.CreateTokenParams{
+	soon, err := c.forge.Tokens.Create(c.ctx, domain.Root(), ports.CreateTokenParams{
 		Label: "soon", Scopes: domain.AllScopes(), ExpiresAt: time.Now().Add(time.Hour),
 	})
 	require.NoError(t, err)

M cmd/ermite/web_test.go +3 -3

 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 var updateGolden = flag.Bool("update", false, "rewrite the golden files of the web tests")
 // branches (one with a slash), two tags and a description.
 func (h *harness) webRepo(name string) {
 	h.t.Helper()
-	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), app.CreateParams{
+	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), ports.CreateRepoParams{
 		Name: h.name(name), Description: "A demo repository", Visibility: domain.VisibilityPublic,
 	})
 	require.NoError(h.t, err)
 // AC4, end to end: a README that attacks the page is neutralised.
 func TestWebReadmeIsNeutralised(t *testing.T) {
 	h := newHarness(t, harnessOpts{})
-	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), app.CreateParams{Name: h.name("evil"), Visibility: domain.VisibilityPublic})
+	_, err := h.forge.Repos.Create(h.ctx, domain.Root(), ports.CreateRepoParams{Name: h.name("evil"), Visibility: domain.VisibilityPublic})
 	require.NoError(t, err)
 	wt := h.t.TempDir()
 	h.mustGit(wt, "init", "-q", "--initial-branch=main")

M internal/adapters/githttp/handler.go +8 -44

 	serviceReceive = "git-receive-pack"
 )
-// Authenticator turns the secret of a request into a principal. It returns
-// domain.ErrUnauthenticated for a secret that is not valid. app.Auth fits.
-type Authenticator interface {
-	Authenticate(ctx context.Context, secret string) (domain.Principal, error)
-}
-// Repos is the read side of the repository use cases. A repository the
-// principal may not read is domain.ErrNotFound. app.Repos fits.
-type Repos interface {
-	Get(ctx context.Context, p domain.Principal, name domain.RepoName) (domain.Repo, error)
-}
-// Pushes opens a repository for a push: it is domain.ErrUnauthenticated for an
-// anonymous caller, domain.ErrNotFound for a repository the caller may not
-// write and cannot see (or that is missing and may not be created),
-// domain.ErrForbidden for one it can see but not write. With create, a missing
-// repository the principal may write is created. app.Pushes fits.
-type Pushes interface {
-	Open(ctx context.Context, p domain.Principal, name domain.RepoName, create bool) error
-}
-// HookTokens hands out the per-request tokens the hooks of a push present
-// back to ermite, and the socket they present them on.
-type HookTokens interface {
-	// Register binds a new token to the repository and principal of a push.
-	// release revokes it and must be called when the request ends.
-	Register(ctx context.Context, repo domain.RepoName, p domain.Principal) (token string, release func())
-	// Socket is the path of the hook socket.
-	Socket() string
-}
-// FailureLimiter counts the failed authentications per client, with the other
-// adapters that authenticate. *clientlimit.Limiter fits.
-type FailureLimiter interface {
-	Blocked(ctx context.Context, addr string) (bool, time.Duration)
-	Fail(ctx context.Context, addr string)
-}
 // Config configures a Handler.
 type Config struct {
-	Auth    Authenticator
+	Auth    ports.AuthService
-	Repos   Repos
+	Repos   ports.RepoLookup
-	Pushes  Pushes
+	Pushes  ports.PushService
 	Backend ports.GitBackend
 	// Hooks provides hook tokens for pushes. It is required.
-	Hooks HookTokens
+	Hooks ports.HookTokens
 	// TrustedProxies are the networks allowed to set X-Forwarded-For.
 	TrustedProxies []netip.Prefix
 	// Limiter counts failed authentications; nil builds a default one.
-	Limiter FailureLimiter
+	Limiter ports.FailureLimiter
 	// MaxBodyBytes bounds the body of a push; 0 means DefaultMaxBodyBytes.
 	// The body of a fetch is bounded by 64 MiB at most.
 	MaxBodyBytes int64
 // Handler serves the smart HTTP routes of Patterns.
 type Handler struct {
 	cfg     Config
-	limiter FailureLimiter
+	limiter ports.FailureLimiter
 	maxBody int64
 	upload, receive chan struct{} // slots of the backends, per service
 }
 // ServeHTTP implements http.Handler.
+//hexcheck:ignore suspicious-business-logic-in-adapter transport orchestration: the authorization decisions are the use cases'
 func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 	var rt route
 	var name domain.RepoName
 }
 // serveBackend runs git http-backend for an authorized request.
+//hexcheck:ignore suspicious-business-logic-in-adapter process and CGI plumbing: no business rule is decided here
 func (h *Handler) serveBackend(w http.ResponseWriter, r *http.Request, rt route, name domain.RepoName, p domain.Principal, client string) {
 	ctx := r.Context()
 	logger := zerowrap.FromCtx(ctx)

M internal/adapters/githttp/handler_test.go +10 -11

 	"github.com/stretchr/testify/require"
 	"bnema.dev/ermite/internal/adapters/githttp"
-	ghmocks "bnema.dev/ermite/internal/adapters/githttp/mocks"
 	"bnema.dev/ermite/internal/clientlimit"
 	"bnema.dev/ermite/internal/domain"
 	"bnema.dev/ermite/internal/ports"
 type rig struct {
 	h       *githttp.Handler
 	srv     *httptest.Server
-	pushes  *ghmocks.Pushes
+	pushes  *mocks.PushService
 	backend *mocks.GitBackend
-	hooks   *ghmocks.HookTokens
+	hooks   *mocks.HookTokens
-	auth    *ghmocks.Authenticator
+	auth    *mocks.AuthService
 	pushFlags  []bool
 	backendErr error
 // stubUseCases answers like the use cases behind the handler: a root and a
 // reader token, a public repository "pub" and a private one "priv".
-func (r *rig) stubUseCases(repos *ghmocks.Repos) {
+func (r *rig) stubUseCases(repos *mocks.RepoLookup) {
 	r.auth.EXPECT().Authenticate(mock.Anything, mock.Anything).RunAndReturn(
 		func(_ context.Context, secret string) (domain.Principal, error) {
 			r.mu.Lock()
 func newRig(t *testing.T, mut func(*githttp.Config)) *rig {
 	t.Helper()
 	r := &rig{
-		pushes: ghmocks.NewPushes(t), backend: mocks.NewGitBackend(t),
+		pushes: mocks.NewPushService(t), backend: mocks.NewGitBackend(t),
-		hooks: ghmocks.NewHookTokens(t), auth: ghmocks.NewAuthenticator(t),
+		hooks: mocks.NewHookTokens(t), auth: mocks.NewAuthService(t),
 	}
-	repos := ghmocks.NewRepos(t)
+	repos := mocks.NewRepoLookup(t)
 	r.stubUseCases(repos)
 	cfg := githttp.Config{
 		Auth: r.auth, Repos: repos, Pushes: r.pushes, Backend: r.backend, Hooks: r.hooks,
 	path := "/pub.git/info/refs?service=git-upload-pack"
 	t.Run("a blocked client is refused before authentication", func(t *testing.T) {
 		t.Parallel()
-		limiter := ghmocks.NewFailureLimiter(t)
+		limiter := mocks.NewFailureLimiter(t)
 		limiter.EXPECT().Blocked(mock.Anything, "127.0.0.1").Return(true, 3*time.Second).Once()
 		r := newRig(t, func(c *githttp.Config) { c.Limiter = limiter })
 		code, _, hdr := r.do(t, "GET", path, "u", "root-secret", nil, nil)
 	})
 	t.Run("an invalid secret is recorded as a failure", func(t *testing.T) {
 		t.Parallel()
-		limiter := ghmocks.NewFailureLimiter(t)
+		limiter := mocks.NewFailureLimiter(t)
 		limiter.EXPECT().Blocked(mock.Anything, "127.0.0.1").Return(false, time.Duration(0)).Once()
 		limiter.EXPECT().Fail(mock.Anything, "127.0.0.1").Once()
 		r := newRig(t, func(c *githttp.Config) { c.Limiter = limiter })
 	})
 	t.Run("a valid secret is not a failure", func(t *testing.T) {
 		t.Parallel()
-		limiter := ghmocks.NewFailureLimiter(t)
+		limiter := mocks.NewFailureLimiter(t)
 		limiter.EXPECT().Blocked(mock.Anything, "127.0.0.1").Return(false, time.Duration(0)).Once()
 		r := newRig(t, func(c *githttp.Config) { c.Limiter = limiter })
 		code, _, _ := r.do(t, "GET", path, "u", "root-secret", nil, nil)

M internal/adapters/githttp/hooks.go +5 -12

 	"github.com/bnema/zerowrap"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
-// PushHooks is what the hook socket asks of the use cases. app.Pushes fits.
-type PushHooks interface {
-	// Check decides a push before Git applies it; an error matching
-	// domain.ErrRejected refuses it, any other error refuses it as a failure.
-	Check(ctx context.Context, p domain.Principal, name domain.RepoName, updates []domain.RefUpdate) error
-	// Record handles an accepted push.
-	Record(ctx context.Context, p domain.Principal, name domain.RepoName, updates []domain.RefUpdate) error
-}
 // readTimeout bounds how long a connection may take to send its request line.
 const readTimeout = 30 * time.Second
 // socket the hooks call back on. It implements HookTokens.
 type HookServer struct {
 	path  string
-	hooks PushHooks
+	hooks ports.PushHookService
 	mu     sync.RWMutex
 	tokens map[string]hookEntry
 	wg     sync.WaitGroup
 }
-var _ HookTokens = (*HookServer)(nil)
+var _ ports.HookTokens = (*HookServer)(nil)
 // NewHookServer builds a server for the socket at path. Call Serve to listen.
-func NewHookServer(path string, hooks PushHooks) *HookServer {
+func NewHookServer(path string, hooks ports.PushHookService) *HookServer {
 	return &HookServer{path: path, hooks: hooks, tokens: make(map[string]hookEntry), conns: make(map[net.Conn]struct{})}
 }
 }
 // handle serves one connection: one request line, one reply line.
+//hexcheck:ignore suspicious-business-logic-in-adapter hook protocol dispatch: the decisions are the use cases'
 func (s *HookServer) handle(ctx context.Context, conn net.Conn) {
 	log := zerowrap.FromCtx(ctx)
 	_ = conn.SetReadDeadline(time.Now().Add(readTimeout))

M internal/adapters/githttp/hooks_test.go +10 -9

 	"github.com/stretchr/testify/require"
 	"bnema.dev/ermite/internal/adapters/githttp"
-	ghmocks "bnema.dev/ermite/internal/adapters/githttp/mocks"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
+	"bnema.dev/ermite/internal/ports/mocks"
 )
 const (
 }
 // startHooks serves a hook socket in a short temporary directory.
-func startHooks(t *testing.T, h githttp.PushHooks) (*githttp.HookServer, string) {
+func startHooks(t *testing.T, h ports.PushHookService) (*githttp.HookServer, string) {
 	t.Helper()
 	dir, err := os.MkdirTemp("", "hk")
 	require.NoError(t, err)
 func TestHookSocketMode(t *testing.T) {
 	t.Parallel()
-	_, sock := startHooks(t, ghmocks.NewPushHooks(t))
+	_, sock := startHooks(t, mocks.NewPushHookService(t))
 	fi, err := os.Stat(sock)
 	require.NoError(t, err)
 	assert.Equal(t, os.FileMode(0o600), fi.Mode().Perm())
 	defer func() { _ = os.RemoveAll(dir) }()
 	sock := filepath.Join(dir, "hook.sock")
 	require.NoError(t, os.WriteFile(sock, []byte("stale"), 0o600))
-	s := githttp.NewHookServer(sock, ghmocks.NewPushHooks(t))
+	s := githttp.NewHookServer(sock, mocks.NewPushHookService(t))
 	require.NoError(t, s.Listen(context.Background()))
 	s.Close(context.Background())
 }
 func TestHookServerRejectsTooLongSocketPath(t *testing.T) {
 	t.Parallel()
-	s := githttp.NewHookServer("/"+strings.Repeat("a", 120)+"/hook.sock", ghmocks.NewPushHooks(t))
+	s := githttp.NewHookServer("/"+strings.Repeat("a", 120)+"/hook.sock", mocks.NewPushHookService(t))
 	err := s.Listen(context.Background())
 	require.Error(t, err)
 	assert.Contains(t, err.Error(), "too long")
 }
 func TestHookProtocol(t *testing.T) {
-	hooks := ghmocks.NewPushHooks(t)
+	hooks := mocks.NewPushHookService(t)
 	srv, sock := startHooks(t, hooks)
 	p := domain.TokenPrincipal(domain.Token{ID: "tok1", Scopes: []domain.Scope{domain.ScopeRepoWrite}})
 	tokenA, releaseA := srv.Register(context.Background(), repoName(t, "alpha"), p)
 // push is already in the repository.
 func TestHookRecordSurvivesShutdown(t *testing.T) {
 	t.Parallel()
-	hooks := ghmocks.NewPushHooks(t)
+	hooks := mocks.NewPushHookService(t)
 	started, proceed := make(chan struct{}), make(chan struct{})
 	var cancelled, hasDeadline bool
 	var ctxMu sync.Mutex
 func TestHookConcurrentTokens(t *testing.T) {
 	t.Parallel()
-	hooks := ghmocks.NewPushHooks(t)
+	hooks := mocks.NewPushHookService(t)
 	srv, sock := startHooks(t, hooks)
 	var wg sync.WaitGroup
 	// Each of the 16 tokens reaches the use case for its own repository, once.
 func TestRunHook(t *testing.T) {
 	ctx := context.Background()
-	hooks := ghmocks.NewPushHooks(t)
+	hooks := mocks.NewPushHookService(t)
 	srv, sock := startHooks(t, hooks)
 	tok, rel := srv.Register(context.Background(), repoName(t, "alpha"), domain.Root())
 	defer rel()

M internal/adapters/rpc/api.go +10 -15

 	"bnema.dev/ermite-api/gen/ermite/ermiteconnect"
 	"bnema.dev/ermite/internal/clientlimit"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // MaxRequestBytes bounds the size of a request message. Responses are not
 // implements, as GetVersion lists them.
 var Features = []string{"repo.update", "events.resume", "merge_requests", "merge_requests.delete_branch", "signing_key", "session"}
-// Authenticator turns a token secret into a principal, or
-// domain.ErrUnauthenticated. app.Auth fits.
-type Authenticator interface {
-	Authenticate(ctx context.Context, secret string) (domain.Principal, error)
-}
 // Config configures the API.
 type Config struct {
-	Auth   Authenticator
+	Auth   ports.AuthService
-	Repos  Repos
+	Repos  ports.RepoService
-	Tokens Tokens
+	Tokens ports.TokenService
-	Browse Browse
+	Browse ports.BrowseService
-	Events Events
+	Events ports.EventService
 	// MergeRequests serves MergeRequestService, SigningKey GetSigningKey.
-	MergeRequests MergeRequests
+	MergeRequests ports.MergeRequestService
-	SigningKey    SigningKey
+	SigningKey    ports.SigningKeyService
 	Version       string
 	// TrustedProxies are the networks allowed to set X-Forwarded-For.
 	TrustedProxies []netip.Prefix
 	// it with the other adapters that authenticate, so that a client has one
 	// budget of failures. Leave it unset rather than assigning a typed nil
 	// pointer (a nil *T in the interface is not nil, and would be called).
-	Limiter FailureLimiter
+	Limiter ports.FailureLimiter
 	// Sessions are the owner's web sessions; nil serves no SessionService.
 	// Leave it unset rather than assigning a typed nil pointer (a nil *T in
 	// the interface is not nil, and the service would be served and called).
-	Sessions Sessions
+	Sessions ports.SessionService
 }
 // API is the set of Connect handlers of the contract.

M internal/adapters/rpc/convert.go +4 -4

 	"google.golang.org/protobuf/types/known/timestamppb"
 	pb "bnema.dev/ermite-api/gen/ermite"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // This file maps domain values to the messages of the contract and back.
 	return "", fmt.Errorf("%w: %v", domain.ErrInvalidVisibility, v)
 }
-func repoToPB(v app.RepoView) *pb.Repo {
+func repoToPB(v ports.RepoView) *pb.Repo {
 	settings := v.Settings
 	if settings.IsZero() {
 		settings = domain.DefaultRepoSettings()
 // watchEventToPB maps one item of a watch; nil when the event has no
 // representation in the contract.
-func watchEventToPB(we app.WatchEvent) *pb.Event {
+func watchEventToPB(we ports.WatchEvent) *pb.Event {
 	if we.Gap {
 		return &pb.Event{Kind: &pb.Event_Gap{Gap: &pb.Gap{}}}
 	}
 	return out
 }
-func repoOrName(we app.WatchEvent, name domain.RepoName, vis domain.Visibility) *pb.Repo {
+func repoOrName(we ports.WatchEvent, name domain.RepoName, vis domain.Visibility) *pb.Repo {
 	if we.Repo != nil {
 		return repoToPB(*we.Repo)
 	}

M internal/adapters/rpc/convert_test.go +5 -5

 	"google.golang.org/protobuf/types/known/fieldmaskpb"
 	pb "bnema.dev/ermite-api/gen/ermite"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // Every value of the domain maps to a real value of the contract, never to
 func TestRepoToPBAlwaysHasSettings(t *testing.T) {
 	t.Parallel()
 	// A repository value without settings (never stored with them) reads as the defaults.
-	r := repoToPB(app.RepoView{Repo: domain.Repo{Name: mustName(t, "x")}})
+	r := repoToPB(ports.RepoView{Repo: domain.Repo{Name: mustName(t, "x")}})
 	assert.Equal(t, []pb.MergeMode{pb.MergeMode_MERGE_MODE_FAST_FORWARD, pb.MergeMode_MERGE_MODE_SQUASH}, r.GetSettings().GetAllowedMergeModes())
 	assert.True(t, r.GetSettings().GetFailingChecksBlock())
 	custom := domain.RepoSettings{AllowedMergeModes: []domain.MergeMode{domain.MergeModeSquash}}
-	r = repoToPB(app.RepoView{Repo: domain.Repo{Name: mustName(t, "x"), Settings: custom}})
+	r = repoToPB(ports.RepoView{Repo: domain.Repo{Name: mustName(t, "x"), Settings: custom}})
 	assert.Equal(t, []pb.MergeMode{pb.MergeMode_MERGE_MODE_SQUASH}, r.GetSettings().GetAllowedMergeModes())
 	assert.False(t, r.GetSettings().GetFailingChecksBlock())
 }
 	} {
 		t.Run(name, func(t *testing.T) {
 			t.Parallel()
-			got := watchEventToPB(app.WatchEvent{ID: "e1", Event: tc.ev})
+			got := watchEventToPB(ports.WatchEvent{ID: "e1", Event: tc.ev})
 			require.NotNil(t, got)
 			assert.Equal(t, "e1", got.GetId())
 			assert.Equal(t, at, got.GetTime().AsTime())
 	}
 	c := domain.Comment{ID: 9, Author: "root", Path: "a.txt", Line: 3, Side: domain.SideOld, CreatedAt: at}
-	got := watchEventToPB(app.WatchEvent{ID: "e2", Event: domain.CommentAdded{Repo: repo, Number: 4, Comment: c, At: at}})
+	got := watchEventToPB(ports.WatchEvent{ID: "e2", Event: domain.CommentAdded{Repo: repo, Number: 4, Comment: c, At: at}})
 	added := got.GetCommentAdded()
 	require.NotNil(t, added)
 	assert.Equal(t, "proj", added.GetRepo())

M internal/adapters/rpc/event.go +4 -4


@@ -8,11 +8,11 @@ import (
8		"connectrpc.com/connect"	8		"connectrpc.com/connect"
9			9
10		pb "bnema.dev/ermite-api/gen/ermite"	10		pb "bnema.dev/ermite-api/gen/ermite"
11	-	"bnema.dev/ermite/internal/app"	11	+	"bnema.dev/ermite/internal/ports"
12		)	12		)
13			13
14		// eventService implements ermiteconnect.EventServiceHandler.	14		// eventService implements ermiteconnect.EventServiceHandler.
15	-	type eventService struct{ events Events }	15	+	type eventService struct{ events ports.EventService }
16			16
17		// Watch streams events until the client goes away or the server stops. The	17		// Watch streams events until the client goes away or the server stops. The
18		// stream ends with success in both cases: the contract has no error for	18		// stream ends with success in both cases: the contract has no error for

@@ -20,7 +20,7 @@ type eventService struct{ events Events }
20		// the caller is revoked or expires, and a caller that has too many streams	20		// the caller is revoked or expires, and a caller that has too many streams
21		// open gets resource_exhausted.	21		// open gets resource_exhausted.
22		func (s eventService) Watch(ctx context.Context, req connect.Request[pb.WatchRequest], stream *connect.ServerStream[pb.WatchResponse]) error {	22		func (s eventService) Watch(ctx context.Context, req connect.Request[pb.WatchRequest], stream *connect.ServerStream[pb.WatchResponse]) error {
23	-	params := app.WatchParams{	23	+	params := ports.WatchParams{
24		Topics: req.Msg.GetTopics(), ResumeAfter: req.Msg.GetResumeAfter(),	24		Topics: req.Msg.GetTopics(), ResumeAfter: req.Msg.GetResumeAfter(),
25		Client: clientFromContext(ctx),	25		Client: clientFromContext(ctx),
26		// A client's call returns when the response begins: send the headers	26		// A client's call returns when the response begins: send the headers

@@ -28,7 +28,7 @@ func (s eventService) Watch(ctx context.Context, req connect.Request[pb.WatchR
28		// them for a nil message. A failure shows on the first real send.	28		// them for a nil message. A failure shows on the first real send.
29		Ready: func() { _ = stream.Send(nil) },	29		Ready: func() { _ = stream.Send(nil) },
30		}	30		}
31	-	err := s.events.Watch(ctx, caller(ctx), params, func(we app.WatchEvent) error {	31	+	err := s.events.Watch(ctx, caller(ctx), params, func(we ports.WatchEvent) error {
32		ev := watchEventToPB(we)	32		ev := watchEventToPB(we)
33		if ev == nil {	33		if ev == nil {
34		return nil	34		return nil

M internal/adapters/rpc/git.go +4 -4

 	"connectrpc.com/connect"
 	pb "bnema.dev/ermite-api/gen/ermite"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // BlobChunkSize is the largest chunk of a GetBlob stream.
 const BlobChunkSize = 64 << 10
 // gitService implements ermiteconnect.GitServiceHandler.
-type gitService struct{ browse Browse }
+type gitService struct{ browse ports.BrowseService }
 // target is the repository and revision most requests start with.
 func target(repo, revision string) (domain.RepoName, domain.Revision, error) {
 	if err != nil {
 		return nil, connectError(ctx, err)
 	}
-	params := app.ListRefsParams{PageSize: int(req.Msg.GetPageSize()), PageToken: req.Msg.GetPageToken()}
+	params := ports.ListRefsParams{PageSize: int(req.Msg.GetPageSize()), PageToken: req.Msg.GetPageToken()}
 	for _, k := range req.Msg.GetKinds() {
 		kind, err := refKindFromPB(k)
 		if err != nil {
 	if err != nil {
 		return nil, connectError(ctx, err)
 	}
-	page, err := s.browse.ListCommits(ctx, caller(ctx), name, app.ListCommitsParams{
+	page, err := s.browse.ListCommits(ctx, caller(ctx), name, ports.ListCommitsParams{
 		Revision: rev, Path: path, PageSize: int(req.Msg.GetPageSize()), PageToken: req.Msg.GetPageToken(),
 	})
 	if err != nil {

M internal/adapters/rpc/git_test.go +12 -12

 	"github.com/stretchr/testify/require"
 	pb "bnema.dev/ermite-api/gen/ermite"
-	"bnema.dev/ermite/internal/adapters/rpc/mocks"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
+	"bnema.dev/ermite/internal/ports/mocks"
 )
 func TestGitServiceGetTree(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			browse := mocks.NewBrowse(t)
+			browse := mocks.NewBrowseService(t)
 			if tt.wantCall {
 				browse.EXPECT().GetTree(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), mock.Anything, mock.Anything, false).
 					Return(domain.Tree{}, tt.usecase).Once()
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			browse := mocks.NewBrowse(t)
+			browse := mocks.NewBrowseService(t)
 			if tt.wantCall {
 				browse.EXPECT().ListRefs(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), mock.Anything).
-					Return(app.RefPage{NextPageToken: "n"}, tt.usecase).Once()
+					Return(ports.RefPage{NextPageToken: "n"}, tt.usecase).Once()
 			}
 			resp, err := (&gitService{browse}).ListRefs(ownerCtx(), connect.NewRequest(tt.req))
 			if tt.wantCode != 0 {
 	for _, tt := range invalid {
 		t.Run("GetCommit "+tt.name, func(t *testing.T) {
 			t.Parallel()
-			_, err := (&gitService{mocks.NewBrowse(t)}).GetCommit(ownerCtx(), connect.NewRequest(&pb.GetCommitRequest{Repo: tt.repo, Revision: tt.rev}))
+			_, err := (&gitService{mocks.NewBrowseService(t)}).GetCommit(ownerCtx(), connect.NewRequest(&pb.GetCommitRequest{Repo: tt.repo, Revision: tt.rev}))
 			requireCode(t, connect.CodeInvalidArgument, err)
 		})
 		t.Run("ResolveRevision "+tt.name, func(t *testing.T) {
 			t.Parallel()
-			_, err := (&gitService{mocks.NewBrowse(t)}).ResolveRevision(ownerCtx(), connect.NewRequest(&pb.ResolveRevisionRequest{Repo: tt.repo, Revision: tt.rev}))
+			_, err := (&gitService{mocks.NewBrowseService(t)}).ResolveRevision(ownerCtx(), connect.NewRequest(&pb.ResolveRevisionRequest{Repo: tt.repo, Revision: tt.rev}))
 			requireCode(t, connect.CodeInvalidArgument, err)
 		})
 	}
 	t.Run("GetCommit not found", func(t *testing.T) {
 		t.Parallel()
-		browse := mocks.NewBrowse(t)
+		browse := mocks.NewBrowseService(t)
 		browse.EXPECT().GetCommit(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), mock.Anything).Return(domain.CommitDetail{}, domain.ErrNotFound).Once()
 		_, err := (&gitService{browse}).GetCommit(ownerCtx(), connect.NewRequest(&pb.GetCommitRequest{Repo: "demo", Revision: "main"}))
 		requireCode(t, connect.CodeNotFound, err)
 	})
 	t.Run("ResolveRevision ok", func(t *testing.T) {
 		t.Parallel()
-		browse := mocks.NewBrowse(t)
+		browse := mocks.NewBrowseService(t)
 		browse.EXPECT().ResolveRevision(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), mock.Anything).
 			Return(domain.ResolvedRevision{Ref: "refs/heads/main"}, nil).Once()
 		resp, err := (&gitService{browse}).ResolveRevision(ownerCtx(), connect.NewRequest(&pb.ResolveRevisionRequest{Repo: "demo", Revision: "main"}))
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			browse := mocks.NewBrowse(t)
+			browse := mocks.NewBrowseService(t)
 			if tt.wantCall {
 				browse.EXPECT().ListCommits(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), mock.Anything).
-					Return(app.CommitPage{}, tt.usecase).Once()
+					Return(ports.HistoryPage{}, tt.usecase).Once()
 			}
 			_, err := (&gitService{browse}).ListCommits(ownerCtx(), connect.NewRequest(tt.req))
 			if tt.wantCode != 0 {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			err := (&gitService{mocks.NewBrowse(t)}).GetBlob(ownerCtx(), connect.NewRequest(tt.req), nil)
+			err := (&gitService{mocks.NewBrowseService(t)}).GetBlob(ownerCtx(), connect.NewRequest(tt.req), nil)
 			requireCode(t, connect.CodeInvalidArgument, err)
 		})
 	}

M internal/adapters/rpc/interceptor.go +3 -2

 	"bnema.dev/ermite-api/gen/ermite/ermiteconnect"
 	"bnema.dev/ermite/internal/clientlimit"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 var errInternal = errors.New("internal error")
 // put there by a server's base context, is ignored and the request is
 // authenticated from its headers.
 type interceptor struct {
-	auth    Authenticator
+	auth    ports.AuthService
-	limiter FailureLimiter
+	limiter ports.FailureLimiter
 	trusted []netip.Prefix
 }

M internal/adapters/rpc/interceptor_test.go +3 -3

 	"github.com/stretchr/testify/require"
 	"bnema.dev/ermite-api/gen/ermite/ermiteconnect"
-	"bnema.dev/ermite/internal/adapters/rpc/mocks"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports/mocks"
 )
 const peer = "203.0.113.7:4242"
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			auth := mocks.NewAuthenticator(t)
+			auth := mocks.NewAuthService(t)
 			limiter := mocks.NewFailureLimiter(t)
 			if tt.wantLimit {
 				wait := time.Duration(0)
 	limiter.EXPECT().Blocked(mock.Anything, "203.0.113.7").Return(false, time.Duration(0)).Once()
 	h := bearerHeader("")
 	h.Set("X-Forwarded-For", "198.51.100.1")
-	i := newInterceptor(Config{Auth: mocks.NewAuthenticator(t), Limiter: limiter})
+	i := newInterceptor(Config{Auth: mocks.NewAuthService(t), Limiter: limiter})
 	_, err := i.authenticate(context.Background(), ermiteconnect.RepoServiceListReposProcedure, peer, h)
 	require.NoError(t, err)
 }

M internal/adapters/rpc/mergerequest.go +6 -6

 	"connectrpc.com/connect"
 	pb "bnema.dev/ermite-api/gen/ermite"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // mergeRequestService implements ermiteconnect.MergeRequestServiceHandler.
-type mergeRequestService struct{ mrs MergeRequests }
+type mergeRequestService struct{ mrs ports.MergeRequestService }
 func mergeRequestStateToPB(s domain.MRState) pb.MergeRequestState {
 	switch s {
 	if err != nil {
 		return nil, connectError(ctx, err)
 	}
-	mr, err := s.mrs.Create(ctx, caller(ctx), name, app.CreateMergeRequestParams{
+	mr, err := s.mrs.Create(ctx, caller(ctx), name, ports.CreateMergeRequestParams{
 		Title: req.Msg.GetTitle(), Description: req.Msg.GetDescription(),
 		Source: req.Msg.GetSourceBranch(), Target: req.Msg.GetTargetBranch(),
 	})
 	if err != nil {
 		return nil, connectError(ctx, err)
 	}
-	page, err := s.mrs.List(ctx, caller(ctx), name, app.ListMergeRequestsParams{
+	page, err := s.mrs.List(ctx, caller(ctx), name, ports.ListMergeRequestsParams{
 		State: state, PageSize: int(req.Msg.GetPageSize()), PageToken: req.Msg.GetPageToken(),
 	})
 	if err != nil {
 	if err != nil {
 		return nil, connectError(ctx, err)
 	}
-	c, err := s.mrs.AddComment(ctx, caller(ctx), name, req.Msg.GetNumber(), app.AddCommentParams{
+	c, err := s.mrs.AddComment(ctx, caller(ctx), name, req.Msg.GetNumber(), ports.AddCommentParams{
 		Path: req.Msg.GetPath(), Line: int(req.Msg.GetLine()), Side: side, Text: req.Msg.GetText(),
 	})
 	if err != nil {
 	if err != nil {
 		return nil, connectError(ctx, err)
 	}
-	res, err := s.mrs.Merge(ctx, caller(ctx), name, req.Msg.GetNumber(), app.MergeParams{
+	res, err := s.mrs.Merge(ctx, caller(ctx), name, req.Msg.GetNumber(), ports.MergeParams{
 		Mode: mode, HeadID: head, DeleteSource: req.Msg.GetDeleteSourceBranch(),
 	})
 	if err != nil {

M internal/adapters/rpc/mergerequest_test.go +19 -19

 	"github.com/stretchr/testify/require"
 	pb "bnema.dev/ermite-api/gen/ermite"
-	"bnema.dev/ermite/internal/adapters/rpc/mocks"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
+	"bnema.dev/ermite/internal/ports/mocks"
 )
 func TestMergeRequestServiceCreate(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			mrs := mocks.NewMergeRequests(t)
+			mrs := mocks.NewMergeRequestService(t)
 			if tt.wantCall {
-				mrs.EXPECT().Create(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), app.CreateMergeRequestParams{
+				mrs.EXPECT().Create(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), ports.CreateMergeRequestParams{
 					Title: "t", Description: "d", Source: "feat", Target: "main",
 				}).Return(domain.MergeRequest{Number: 7, Source: "feat", Target: "main", State: domain.MRStateOpen}, tt.usecase).Once()
 			}
 func TestMergeRequestServiceListRejectsUnknownState(t *testing.T) {
 	t.Parallel()
-	_, err := (&mergeRequestService{mocks.NewMergeRequests(t)}).ListMergeRequests(ownerCtx(),
+	_, err := (&mergeRequestService{mocks.NewMergeRequestService(t)}).ListMergeRequests(ownerCtx(),
 		connect.NewRequest(&pb.ListMergeRequestsRequest{Repo: "demo", State: pb.MergeRequestState(99)}))
 	requireCode(t, connect.CodeInvalidArgument, err)
 }
 func TestMergeRequestServiceListFiltersByState(t *testing.T) {
 	t.Parallel()
-	mrs := mocks.NewMergeRequests(t)
+	mrs := mocks.NewMergeRequestService(t)
-	mrs.EXPECT().List(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), app.ListMergeRequestsParams{
+	mrs.EXPECT().List(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), ports.ListMergeRequestsParams{
 		State: domain.MRStateMerged, PageSize: 3, PageToken: "tok",
-	}).Return(app.MergeRequestPage{MergeRequests: []domain.MergeRequest{{Number: 1}}, NextPageToken: "n"}, nil).Once()
+	}).Return(ports.MergeRequestPage{MergeRequests: []domain.MergeRequest{{Number: 1}}, NextPageToken: "n"}, nil).Once()
 	resp, err := (&mergeRequestService{mrs}).ListMergeRequests(ownerCtx(), connect.NewRequest(&pb.ListMergeRequestsRequest{
 		Repo: "demo", State: pb.MergeRequestState_MERGE_REQUEST_STATE_MERGED, PageSize: 3, PageToken: "tok",
 	}))
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			mrs := mocks.NewMergeRequests(t)
+			mrs := mocks.NewMergeRequestService(t)
 			if tt.wantCall {
 				mrs.EXPECT().AddComment(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), int64(2), mock.Anything).
 					Return(domain.Comment{ID: 5}, tt.usecase).Once()
 	for _, id := range []string{"", "abc", "-1", "0", "007", "99999999999999999999"} {
 		t.Run(id, func(t *testing.T) {
 			t.Parallel()
-			mrs := mocks.NewMergeRequests(t)
+			mrs := mocks.NewMergeRequestService(t)
 			mrs.EXPECT().ResolveComment(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), int64(1), int64(0), true).
 				Return(domain.Comment{}, domain.ErrNotFound).Once()
 			_, err := (&mergeRequestService{mrs}).ResolveComment(ownerCtx(), connect.NewRequest(&pb.ResolveCommentRequest{
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			mrs := mocks.NewMergeRequests(t)
+			mrs := mocks.NewMergeRequestService(t)
 			if tt.wantCall {
-				mrs.EXPECT().Merge(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), int64(1), mock.MatchedBy(func(p app.MergeParams) bool {
+				mrs.EXPECT().Merge(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), int64(1), mock.MatchedBy(func(p ports.MergeParams) bool {
 					return p.DeleteSource == tt.req.GetDeleteSourceBranch() && (tt.req.GetHeadId() == "") == p.HeadID.IsZero()
-				})).Return(app.MergeResult{MergeRequest: domain.MergeRequest{Number: 1}, SourceDeleted: true}, tt.usecase).Once()
+				})).Return(ports.MergeResult{MergeRequest: domain.MergeRequest{Number: 1}, SourceDeleted: true}, tt.usecase).Once()
 			}
 			resp, err := (&mergeRequestService{mrs}).MergeMergeRequest(ownerCtx(), connect.NewRequest(tt.req))
 			if tt.wantCode != 0 {
 	t.Parallel()
 	t.Run("close not found", func(t *testing.T) {
 		t.Parallel()
-		mrs := mocks.NewMergeRequests(t)
+		mrs := mocks.NewMergeRequestService(t)
 		mrs.EXPECT().Close(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), int64(9)).Return(domain.MergeRequest{}, domain.ErrNotFound).Once()
 		_, err := (&mergeRequestService{mrs}).CloseMergeRequest(ownerCtx(), connect.NewRequest(&pb.CloseMergeRequestRequest{Repo: "demo", Number: 9}))
 		requireCode(t, connect.CodeNotFound, err)
 	})
 	t.Run("close ok", func(t *testing.T) {
 		t.Parallel()
-		mrs := mocks.NewMergeRequests(t)
+		mrs := mocks.NewMergeRequestService(t)
 		mrs.EXPECT().Close(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), int64(9)).Return(domain.MergeRequest{Number: 9, State: domain.MRStateClosed}, nil).Once()
 		resp, err := (&mergeRequestService{mrs}).CloseMergeRequest(ownerCtx(), connect.NewRequest(&pb.CloseMergeRequestRequest{Repo: "demo", Number: 9}))
 		require.NoError(t, err)
 	})
 	t.Run("mark read rejects a short head", func(t *testing.T) {
 		t.Parallel()
-		_, err := (&mergeRequestService{mocks.NewMergeRequests(t)}).MarkRead(ownerCtx(),
+		_, err := (&mergeRequestService{mocks.NewMergeRequestService(t)}).MarkRead(ownerCtx(),
 			connect.NewRequest(&pb.MarkReadRequest{Repo: "demo", Number: 1, HeadId: "abc"}))
 		requireCode(t, connect.CodeInvalidArgument, err)
 	})
 	t.Run("mark read unauthenticated", func(t *testing.T) {
 		t.Parallel()
-		mrs := mocks.NewMergeRequests(t)
+		mrs := mocks.NewMergeRequestService(t)
 		mrs.EXPECT().MarkRead(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), int64(1), domain.ObjectID{}).Return(domain.ObjectID{}, domain.ErrUnauthenticated).Once()
 		_, err := (&mergeRequestService{mrs}).MarkRead(ownerCtx(), connect.NewRequest(&pb.MarkReadRequest{Repo: "demo", Number: 1}))
 		requireCode(t, connect.CodeUnauthenticated, err)
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			mrs := mocks.NewMergeRequests(t)
+			mrs := mocks.NewMergeRequestService(t)
 			mrs.EXPECT().Get(mock.Anything, domain.Owner(), mustRepoName(t, "demo"), int64(4), true).
-				Return(app.MergeRequestDetail{MergeRequest: domain.MergeRequest{Number: 4}, CommitsTruncated: true}, tt.usecase).Once()
+				Return(ports.MergeRequestDetail{MergeRequest: domain.MergeRequest{Number: 4}, CommitsTruncated: true}, tt.usecase).Once()
 			resp, err := (&mergeRequestService{mrs}).GetMergeRequest(ownerCtx(), connect.NewRequest(&pb.GetMergeRequestRequest{Repo: "demo", Number: 4, SinceLastRead: true}))
 			if tt.wantCode != 0 {
 				requireCode(t, tt.wantCode, err)

D internal/adapters/rpc/mocks/Authenticator.go +0 -114

@@ -1,114 +0,0 @@
1	-	// Code generated by mockery; DO NOT EDIT.
2	-	// github.com/vektra/mockery
3	-	// template: testify
4	-
5	-	package mocks
6	-
7	-	import (
8	-	"context"
9	-
10	-	"bnema.dev/ermite/internal/domain"
11	-	mock "github.com/stretchr/testify/mock"
12	-	)
13	-
14	-	// NewAuthenticator creates a new instance of Authenticator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15	-	// The first argument is typically a *testing.T value.
16	-	func NewAuthenticator(t interface {
17	-	mock.TestingT
18	-	Cleanup(func())
19	-	}) *Authenticator {
20	-	if helper, ok := t.(interface{ Helper() }); ok {
21	-	helper.Helper()
22	-	}
23	-
24	-	mock := &Authenticator{}
25	-	mock.Mock.Test(t)
26	-
27	-	t.Cleanup(func() {
28	-	if helper, ok := t.(interface{ Helper() }); ok {
29	-	helper.Helper()
30	-	}
31	-	mock.AssertExpectations(t)
32	-	})
33	-
34	-	return mock
35	-	}
36	-
37	-	// Authenticator is an autogenerated mock type for the Authenticator type
38	-	type Authenticator struct {
39	-	mock.Mock
40	-	}
41	-
42	-	type Authenticator_Expecter struct {
43	-	mock *mock.Mock
44	-	}
45	-
46	-	func (_m Authenticator) EXPECT() Authenticator_Expecter {
47	-	return &Authenticator_Expecter{mock: &_m.Mock}
48	-	}
49	-
50	-	// Authenticate provides a mock function for the type Authenticator
51	-	func (_mock *Authenticator) Authenticate(ctx context.Context, secret string) (domain.Principal, error) {
52	-	ret := _mock.Called(ctx, secret)
53	-
54	-	if len(ret) == 0 {
55	-	panic("no return value specified for Authenticate")
56	-	}
57	-
58	-	var r0 domain.Principal
59	-	var r1 error
60	-	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (domain.Principal, error)); ok {
61	-	return returnFunc(ctx, secret)
62	-	}
63	-	if returnFunc, ok := ret.Get(0).(func(context.Context, string) domain.Principal); ok {
64	-	r0 = returnFunc(ctx, secret)
65	-	} else {
66	-	r0 = ret.Get(0).(domain.Principal)
67	-	}
68	-	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
69	-	r1 = returnFunc(ctx, secret)
70	-	} else {
71	-	r1 = ret.Error(1)
72	-	}
73	-	return r0, r1
74	-	}
75	-
76	-	// Authenticator_Authenticate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Authenticate'
77	-	type Authenticator_Authenticate_Call struct {
78	-	*mock.Call
79	-	}
80	-
81	-	// Authenticate is a helper method to define mock.On call
82	-	// - ctx context.Context
83	-	// - secret string
84	-	func (_e Authenticator_Expecter) Authenticate(ctx any, secret any) Authenticator_Authenticate_Call {
85	-	return &Authenticator_Authenticate_Call{Call: _e.mock.On("Authenticate", ctx, secret)}
86	-	}
87	-
88	-	func (_c Authenticator_Authenticate_Call) Run(run func(ctx context.Context, secret string)) Authenticator_Authenticate_Call {
89	-	_c.Call.Run(func(args mock.Arguments) {
90	-	var arg0 context.Context
91	-	if args[0] != nil {
92	-	arg0 = args[0].(context.Context)
93	-	}
94	-	var arg1 string
95	-	if args[1] != nil {
96	-	arg1 = args[1].(string)
97	-	}
98	-	run(
99	-	arg0,
100	-	arg1,
101	-	)
102	-	})
103	-	return _c
104	-	}
105	-
106	-	func (_c Authenticator_Authenticate_Call) Return(principal domain.Principal, err error) Authenticator_Authenticate_Call {
107	-	_c.Call.Return(principal, err)
108	-	return _c
109	-	}
110	-
111	-	func (_c Authenticator_Authenticate_Call) RunAndReturn(run func(ctx context.Context, secret string) (domain.Principal, error)) Authenticator_Authenticate_Call {
112	-	_c.Call.Return(run)
113	-	return _c
114	-	}

D internal/adapters/rpc/mocks/Events.go +0 -118

@@ -1,118 +0,0 @@
1	-	// Code generated by mockery; DO NOT EDIT.
2	-	// github.com/vektra/mockery
3	-	// template: testify
4	-
5	-	package mocks
6	-
7	-	import (
8	-	"context"
9	-
10	-	"bnema.dev/ermite/internal/app"
11	-	"bnema.dev/ermite/internal/domain"
12	-	mock "github.com/stretchr/testify/mock"
13	-	)
14	-
15	-	// NewEvents creates a new instance of Events. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
16	-	// The first argument is typically a *testing.T value.
17	-	func NewEvents(t interface {
18	-	mock.TestingT
19	-	Cleanup(func())
20	-	}) *Events {
21	-	if helper, ok := t.(interface{ Helper() }); ok {
22	-	helper.Helper()
23	-	}
24	-
25	-	mock := &Events{}
26	-	mock.Mock.Test(t)
27	-
28	-	t.Cleanup(func() {
29	-	if helper, ok := t.(interface{ Helper() }); ok {
30	-	helper.Helper()
31	-	}
32	-	mock.AssertExpectations(t)
33	-	})
34	-
35	-	return mock
36	-	}
37	-
38	-	// Events is an autogenerated mock type for the Events type
39	-	type Events struct {
40	-	mock.Mock
41	-	}
42	-
43	-	type Events_Expecter struct {
44	-	mock *mock.Mock
45	-	}
46	-
47	-	func (_m Events) EXPECT() Events_Expecter {
48	-	return &Events_Expecter{mock: &_m.Mock}
49	-	}
50	-
51	-	// Watch provides a mock function for the type Events
52	-	func (_mock *Events) Watch(ctx context.Context, p domain.Principal, params app.WatchParams, send func(app.WatchEvent) error) error {
53	-	ret := _mock.Called(ctx, p, params, send)
54	-
55	-	if len(ret) == 0 {
56	-	panic("no return value specified for Watch")
57	-	}
58	-
59	-	var r0 error
60	-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, app.WatchParams, func(app.WatchEvent) error) error); ok {
61	-	r0 = returnFunc(ctx, p, params, send)
62	-	} else {
63	-	r0 = ret.Error(0)
64	-	}
65	-	return r0
66	-	}
67	-
68	-	// Events_Watch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Watch'
69	-	type Events_Watch_Call struct {
70	-	*mock.Call
71	-	}
72	-
73	-	// Watch is a helper method to define mock.On call
74	-	// - ctx context.Context
75	-	// - p domain.Principal
76	-	// - params app.WatchParams
77	-	// - send func(app.WatchEvent) error
78	-	func (_e Events_Expecter) Watch(ctx any, p any, params any, send any) Events_Watch_Call {
79	-	return &Events_Watch_Call{Call: _e.mock.On("Watch", ctx, p, params, send)}
80	-	}
81	-
82	-	func (_c Events_Watch_Call) Run(run func(ctx context.Context, p domain.Principal, params app.WatchParams, send func(app.WatchEvent) error)) Events_Watch_Call {
83	-	_c.Call.Run(func(args mock.Arguments) {
84	-	var arg0 context.Context
85	-	if args[0] != nil {
86	-	arg0 = args[0].(context.Context)
87	-	}
88	-	var arg1 domain.Principal
89	-	if args[1] != nil {
90	-	arg1 = args[1].(domain.Principal)
91	-	}
92	-	var arg2 app.WatchParams
93	-	if args[2] != nil {
94	-	arg2 = args[2].(app.WatchParams)
95	-	}
96	-	var arg3 func(app.WatchEvent) error
97	-	if args[3] != nil {
98	-	arg3 = args[3].(func(app.WatchEvent) error)
99	-	}
100	-	run(
101	-	arg0,
102	-	arg1,
103	-	arg2,
104	-	arg3,
105	-	)
106	-	})
107	-	return _c
108	-	}
109	-
110	-	func (_c Events_Watch_Call) Return(err error) Events_Watch_Call {
111	-	_c.Call.Return(err)
112	-	return _c
113	-	}
114	-
115	-	func (_c Events_Watch_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, params app.WatchParams, send func(app.WatchEvent) error) error) Events_Watch_Call {
116	-	_c.Call.Return(run)
117	-	return _c
118	-	}

D internal/adapters/rpc/mocks/FailureLimiter.go +0 -160

@@ -1,160 +0,0 @@
1	-	// Code generated by mockery; DO NOT EDIT.
2	-	// github.com/vektra/mockery
3	-	// template: testify
4	-
5	-	package mocks
6	-
7	-	import (
8	-	"context"
9	-	"time"
10	-
11	-	mock "github.com/stretchr/testify/mock"
12	-	)
13	-
14	-	// NewFailureLimiter creates a new instance of FailureLimiter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15	-	// The first argument is typically a *testing.T value.
16	-	func NewFailureLimiter(t interface {
17	-	mock.TestingT
18	-	Cleanup(func())
19	-	}) *FailureLimiter {
20	-	if helper, ok := t.(interface{ Helper() }); ok {
21	-	helper.Helper()
22	-	}
23	-
24	-	mock := &FailureLimiter{}
25	-	mock.Mock.Test(t)
26	-
27	-	t.Cleanup(func() {
28	-	if helper, ok := t.(interface{ Helper() }); ok {
29	-	helper.Helper()
30	-	}
31	-	mock.AssertExpectations(t)
32	-	})
33	-
34	-	return mock
35	-	}
36	-
37	-	// FailureLimiter is an autogenerated mock type for the FailureLimiter type
38	-	type FailureLimiter struct {
39	-	mock.Mock
40	-	}
41	-
42	-	type FailureLimiter_Expecter struct {
43	-	mock *mock.Mock
44	-	}
45	-
46	-	func (_m FailureLimiter) EXPECT() FailureLimiter_Expecter {
47	-	return &FailureLimiter_Expecter{mock: &_m.Mock}
48	-	}
49	-
50	-	// Blocked provides a mock function for the type FailureLimiter
51	-	func (_mock *FailureLimiter) Blocked(ctx context.Context, addr string) (bool, time.Duration) {
52	-	ret := _mock.Called(ctx, addr)
53	-
54	-	if len(ret) == 0 {
55	-	panic("no return value specified for Blocked")
56	-	}
57	-
58	-	var r0 bool
59	-	var r1 time.Duration
60	-	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, time.Duration)); ok {
61	-	return returnFunc(ctx, addr)
62	-	}
63	-	if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
64	-	r0 = returnFunc(ctx, addr)
65	-	} else {
66	-	r0 = ret.Get(0).(bool)
67	-	}
68	-	if returnFunc, ok := ret.Get(1).(func(context.Context, string) time.Duration); ok {
69	-	r1 = returnFunc(ctx, addr)
70	-	} else {
71	-	r1 = ret.Get(1).(time.Duration)
72	-	}
73	-	return r0, r1
74	-	}
75	-
76	-	// FailureLimiter_Blocked_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Blocked'
77	-	type FailureLimiter_Blocked_Call struct {
78	-	*mock.Call
79	-	}
80	-
81	-	// Blocked is a helper method to define mock.On call
82	-	// - ctx context.Context
83	-	// - addr string
84	-	func (_e FailureLimiter_Expecter) Blocked(ctx any, addr any) FailureLimiter_Blocked_Call {
85	-	return &FailureLimiter_Blocked_Call{Call: _e.mock.On("Blocked", ctx, addr)}
86	-	}
87	-
88	-	func (_c FailureLimiter_Blocked_Call) Run(run func(ctx context.Context, addr string)) FailureLimiter_Blocked_Call {
89	-	_c.Call.Run(func(args mock.Arguments) {
90	-	var arg0 context.Context
91	-	if args[0] != nil {
92	-	arg0 = args[0].(context.Context)
93	-	}
94	-	var arg1 string
95	-	if args[1] != nil {
96	-	arg1 = args[1].(string)
97	-	}
98	-	run(
99	-	arg0,
100	-	arg1,
101	-	)
102	-	})
103	-	return _c
104	-	}
105	-
106	-	func (_c FailureLimiter_Blocked_Call) Return(b bool, duration time.Duration) FailureLimiter_Blocked_Call {
107	-	_c.Call.Return(b, duration)
108	-	return _c
109	-	}
110	-
111	-	func (_c FailureLimiter_Blocked_Call) RunAndReturn(run func(ctx context.Context, addr string) (bool, time.Duration)) FailureLimiter_Blocked_Call {
112	-	_c.Call.Return(run)
113	-	return _c
114	-	}
115	-
116	-	// Fail provides a mock function for the type FailureLimiter
117	-	func (_mock *FailureLimiter) Fail(ctx context.Context, addr string) {
118	-	_mock.Called(ctx, addr)
119	-	return
120	-	}
121	-
122	-	// FailureLimiter_Fail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Fail'
123	-	type FailureLimiter_Fail_Call struct {
124	-	*mock.Call
125	-	}
126	-
127	-	// Fail is a helper method to define mock.On call
128	-	// - ctx context.Context
129	-	// - addr string
130	-	func (_e FailureLimiter_Expecter) Fail(ctx any, addr any) FailureLimiter_Fail_Call {
131	-	return &FailureLimiter_Fail_Call{Call: _e.mock.On("Fail", ctx, addr)}
132	-	}
133	-
134	-	func (_c FailureLimiter_Fail_Call) Run(run func(ctx context.Context, addr string)) FailureLimiter_Fail_Call {
135	-	_c.Call.Run(func(args mock.Arguments) {
136	-	var arg0 context.Context
137	-	if args[0] != nil {
138	-	arg0 = args[0].(context.Context)
139	-	}
140	-	var arg1 string
141	-	if args[1] != nil {
142	-	arg1 = args[1].(string)
143	-	}
144	-	run(
145	-	arg0,
146	-	arg1,
147	-	)
148	-	})
149	-	return _c
150	-	}
151	-
152	-	func (_c FailureLimiter_Fail_Call) Return() FailureLimiter_Fail_Call {
153	-	_c.Call.Return()
154	-	return _c
155	-	}
156	-
157	-	func (_c FailureLimiter_Fail_Call) RunAndReturn(run func(ctx context.Context, addr string)) FailureLimiter_Fail_Call {
158	-	_c.Run(run)
159	-	return _c
160	-	}

D internal/adapters/rpc/mocks/Sessions.go +0 -172

@@ -1,172 +0,0 @@
1	-	// Code generated by mockery; DO NOT EDIT.
2	-	// github.com/vektra/mockery
3	-	// template: testify
4	-
5	-	package mocks
6	-
7	-	import (
8	-	"context"
9	-
10	-	"bnema.dev/ermite/internal/app"
11	-	"bnema.dev/ermite/internal/domain"
12	-	mock "github.com/stretchr/testify/mock"
13	-	)
14	-
15	-	// NewSessions creates a new instance of Sessions. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
16	-	// The first argument is typically a *testing.T value.
17	-	func NewSessions(t interface {
18	-	mock.TestingT
19	-	Cleanup(func())
20	-	}) *Sessions {
21	-	if helper, ok := t.(interface{ Helper() }); ok {
22	-	helper.Helper()
23	-	}
24	-
25	-	mock := &Sessions{}
26	-	mock.Mock.Test(t)
27	-
28	-	t.Cleanup(func() {
29	-	if helper, ok := t.(interface{ Helper() }); ok {
30	-	helper.Helper()
31	-	}
32	-	mock.AssertExpectations(t)
33	-	})
34	-
35	-	return mock
36	-	}
37	-
38	-	// Sessions is an autogenerated mock type for the Sessions type
39	-	type Sessions struct {
40	-	mock.Mock
41	-	}
42	-
43	-	type Sessions_Expecter struct {
44	-	mock *mock.Mock
45	-	}
46	-
47	-	func (_m Sessions) EXPECT() Sessions_Expecter {
48	-	return &Sessions_Expecter{mock: &_m.Mock}
49	-	}
50	-
51	-	// CreateLoginLink provides a mock function for the type Sessions
52	-	func (_mock *Sessions) CreateLoginLink(ctx context.Context, p domain.Principal) (app.LoginLink, error) {
53	-	ret := _mock.Called(ctx, p)
54	-
55	-	if len(ret) == 0 {
56	-	panic("no return value specified for CreateLoginLink")
57	-	}
58	-
59	-	var r0 app.LoginLink
60	-	var r1 error
61	-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal) (app.LoginLink, error)); ok {
62	-	return returnFunc(ctx, p)
63	-	}
64	-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal) app.LoginLink); ok {
65	-	r0 = returnFunc(ctx, p)
66	-	} else {
67	-	r0 = ret.Get(0).(app.LoginLink)
68	-	}
69	-	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal) error); ok {
70	-	r1 = returnFunc(ctx, p)
71	-	} else {
72	-	r1 = ret.Error(1)
73	-	}
74	-	return r0, r1
75	-	}
76	-
77	-	// Sessions_CreateLoginLink_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLoginLink'
78	-	type Sessions_CreateLoginLink_Call struct {
79	-	*mock.Call
80	-	}
81	-
82	-	// CreateLoginLink is a helper method to define mock.On call
83	-	// - ctx context.Context
84	-	// - p domain.Principal
85	-	func (_e Sessions_Expecter) CreateLoginLink(ctx any, p any) Sessions_CreateLoginLink_Call {
86	-	return &Sessions_CreateLoginLink_Call{Call: _e.mock.On("CreateLoginLink", ctx, p)}
87	-	}
88	-
89	-	func (_c Sessions_CreateLoginLink_Call) Run(run func(ctx context.Context, p domain.Principal)) Sessions_CreateLoginLink_Call {
90	-	_c.Call.Run(func(args mock.Arguments) {
91	-	var arg0 context.Context
92	-	if args[0] != nil {
93	-	arg0 = args[0].(context.Context)
94	-	}
95	-	var arg1 domain.Principal
96	-	if args[1] != nil {
97	-	arg1 = args[1].(domain.Principal)
98	-	}
99	-	run(
100	-	arg0,
101	-	arg1,
102	-	)
103	-	})
104	-	return _c
105	-	}
106	-
107	-	func (_c Sessions_CreateLoginLink_Call) Return(loginLink app.LoginLink, err error) Sessions_CreateLoginLink_Call {
108	-	_c.Call.Return(loginLink, err)
109	-	return _c
110	-	}
111	-
112	-	func (_c Sessions_CreateLoginLink_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal) (app.LoginLink, error)) Sessions_CreateLoginLink_Call {
113	-	_c.Call.Return(run)
114	-	return _c
115	-	}
116	-
117	-	// SignOutEverywhere provides a mock function for the type Sessions
118	-	func (_mock *Sessions) SignOutEverywhere(ctx context.Context, p domain.Principal) error {
119	-	ret := _mock.Called(ctx, p)
120	-
121	-	if len(ret) == 0 {
122	-	panic("no return value specified for SignOutEverywhere")
123	-	}
124	-
125	-	var r0 error
126	-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal) error); ok {
127	-	r0 = returnFunc(ctx, p)
128	-	} else {
129	-	r0 = ret.Error(0)
130	-	}
131	-	return r0
132	-	}
133	-
134	-	// Sessions_SignOutEverywhere_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignOutEverywhere'
135	-	type Sessions_SignOutEverywhere_Call struct {
136	-	*mock.Call
137	-	}
138	-
139	-	// SignOutEverywhere is a helper method to define mock.On call
140	-	// - ctx context.Context
141	-	// - p domain.Principal
142	-	func (_e Sessions_Expecter) SignOutEverywhere(ctx any, p any) Sessions_SignOutEverywhere_Call {
143	-	return &Sessions_SignOutEverywhere_Call{Call: _e.mock.On("SignOutEverywhere", ctx, p)}
144	-	}
145	-
146	-	func (_c Sessions_SignOutEverywhere_Call) Run(run func(ctx context.Context, p domain.Principal)) Sessions_SignOutEverywhere_Call {
147	-	_c.Call.Run(func(args mock.Arguments) {
148	-	var arg0 context.Context
149	-	if args[0] != nil {
150	-	arg0 = args[0].(context.Context)
151	-	}
152	-	var arg1 domain.Principal
153	-	if args[1] != nil {
154	-	arg1 = args[1].(domain.Principal)
155	-	}
156	-	run(
157	-	arg0,
158	-	arg1,
159	-	)
160	-	})
161	-	return _c
162	-	}
163	-
164	-	func (_c Sessions_SignOutEverywhere_Call) Return(err error) Sessions_SignOutEverywhere_Call {
165	-	_c.Call.Return(err)
166	-	return _c
167	-	}
168	-
169	-	func (_c Sessions_SignOutEverywhere_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal) error) Sessions_SignOutEverywhere_Call {
170	-	_c.Call.Return(run)
171	-	return _c
172	-	}

D internal/adapters/rpc/mocks/SigningKey.go +0 -90

@@ -1,90 +0,0 @@
1	-	// Code generated by mockery; DO NOT EDIT.
2	-	// github.com/vektra/mockery
3	-	// template: testify
4	-
5	-	package mocks
6	-
7	-	import (
8	-	"bnema.dev/ermite/internal/domain"
9	-	mock "github.com/stretchr/testify/mock"
10	-	)
11	-
12	-	// NewSigningKey creates a new instance of SigningKey. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
13	-	// The first argument is typically a *testing.T value.
14	-	func NewSigningKey(t interface {
15	-	mock.TestingT
16	-	Cleanup(func())
17	-	}) *SigningKey {
18	-	if helper, ok := t.(interface{ Helper() }); ok {
19	-	helper.Helper()
20	-	}
21	-
22	-	mock := &SigningKey{}
23	-	mock.Mock.Test(t)
24	-
25	-	t.Cleanup(func() {
26	-	if helper, ok := t.(interface{ Helper() }); ok {
27	-	helper.Helper()
28	-	}
29	-	mock.AssertExpectations(t)
30	-	})
31	-
32	-	return mock
33	-	}
34	-
35	-	// SigningKey is an autogenerated mock type for the SigningKey type
36	-	type SigningKey struct {
37	-	mock.Mock
38	-	}
39	-
40	-	type SigningKey_Expecter struct {
41	-	mock *mock.Mock
42	-	}
43	-
44	-	func (_m SigningKey) EXPECT() SigningKey_Expecter {
45	-	return &SigningKey_Expecter{mock: &_m.Mock}
46	-	}
47	-
48	-	// Info provides a mock function for the type SigningKey
49	-	func (_mock *SigningKey) Info() domain.SigningKeyInfo {
50	-	ret := _mock.Called()
51	-
52	-	if len(ret) == 0 {
53	-	panic("no return value specified for Info")
54	-	}
55	-
56	-	var r0 domain.SigningKeyInfo
57	-	if returnFunc, ok := ret.Get(0).(func() domain.SigningKeyInfo); ok {
58	-	r0 = returnFunc()
59	-	} else {
60	-	r0 = ret.Get(0).(domain.SigningKeyInfo)
61	-	}
62	-	return r0
63	-	}
64	-
65	-	// SigningKey_Info_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Info'
66	-	type SigningKey_Info_Call struct {
67	-	*mock.Call
68	-	}
69	-
70	-	// Info is a helper method to define mock.On call
71	-	func (_e SigningKey_Expecter) Info() SigningKey_Info_Call {
72	-	return &SigningKey_Info_Call{Call: _e.mock.On("Info")}
73	-	}
74	-
75	-	func (_c SigningKey_Info_Call) Run(run func()) SigningKey_Info_Call {
76	-	_c.Call.Run(func(args mock.Arguments) {
77	-	run()
78	-	})
79	-	return _c
80	-	}
81	-
82	-	func (_c SigningKey_Info_Call) Return(signingKeyInfo domain.SigningKeyInfo) SigningKey_Info_Call {
83	-	_c.Call.Return(signingKeyInfo)
84	-	return _c
85	-	}
86	-
87	-	func (_c SigningKey_Info_Call) RunAndReturn(run func() domain.SigningKeyInfo) SigningKey_Info_Call {
88	-	_c.Call.Return(run)
89	-	return _c
90	-	}

D internal/adapters/rpc/mocks/Tokens.go +0 -262

@@ -1,262 +0,0 @@
1	-	// Code generated by mockery; DO NOT EDIT.
2	-	// github.com/vektra/mockery
3	-	// template: testify
4	-
5	-	package mocks
6	-
7	-	import (
8	-	"context"
9	-
10	-	"bnema.dev/ermite/internal/app"
11	-	"bnema.dev/ermite/internal/domain"
12	-	mock "github.com/stretchr/testify/mock"
13	-	)
14	-
15	-	// NewTokens creates a new instance of Tokens. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
16	-	// The first argument is typically a *testing.T value.
17	-	func NewTokens(t interface {
18	-	mock.TestingT
19	-	Cleanup(func())
20	-	}) *Tokens {
21	-	if helper, ok := t.(interface{ Helper() }); ok {
22	-	helper.Helper()
23	-	}
24	-
25	-	mock := &Tokens{}
26	-	mock.Mock.Test(t)
27	-
28	-	t.Cleanup(func() {
29	-	if helper, ok := t.(interface{ Helper() }); ok {
30	-	helper.Helper()
31	-	}
32	-	mock.AssertExpectations(t)
33	-	})
34	-
35	-	return mock
36	-	}
37	-
38	-	// Tokens is an autogenerated mock type for the Tokens type
39	-	type Tokens struct {
40	-	mock.Mock
41	-	}
42	-
43	-	type Tokens_Expecter struct {
44	-	mock *mock.Mock
45	-	}
46	-
47	-	func (_m Tokens) EXPECT() Tokens_Expecter {
48	-	return &Tokens_Expecter{mock: &_m.Mock}
49	-	}
50	-
51	-	// Create provides a mock function for the type Tokens
52	-	func (_mock *Tokens) Create(ctx context.Context, p domain.Principal, params app.CreateTokenParams) (app.CreatedToken, error) {
53	-	ret := _mock.Called(ctx, p, params)
54	-
55	-	if len(ret) == 0 {
56	-	panic("no return value specified for Create")
57	-	}
58	-
59	-	var r0 app.CreatedToken
60	-	var r1 error
61	-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, app.CreateTokenParams) (app.CreatedToken, error)); ok {
62	-	return returnFunc(ctx, p, params)
63	-	}
64	-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, app.CreateTokenParams) app.CreatedToken); ok {
65	-	r0 = returnFunc(ctx, p, params)
66	-	} else {
67	-	r0 = ret.Get(0).(app.CreatedToken)
68	-	}
69	-	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, app.CreateTokenParams) error); ok {
70	-	r1 = returnFunc(ctx, p, params)
71	-	} else {
72	-	r1 = ret.Error(1)
73	-	}
74	-	return r0, r1
75	-	}
76	-
77	-	// Tokens_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
78	-	type Tokens_Create_Call struct {
79	-	*mock.Call
80	-	}
81	-
82	-	// Create is a helper method to define mock.On call
83	-	// - ctx context.Context
84	-	// - p domain.Principal
85	-	// - params app.CreateTokenParams
86	-	func (_e Tokens_Expecter) Create(ctx any, p any, params any) Tokens_Create_Call {
87	-	return &Tokens_Create_Call{Call: _e.mock.On("Create", ctx, p, params)}
88	-	}
89	-
90	-	func (_c Tokens_Create_Call) Run(run func(ctx context.Context, p domain.Principal, params app.CreateTokenParams)) Tokens_Create_Call {
91	-	_c.Call.Run(func(args mock.Arguments) {
92	-	var arg0 context.Context
93	-	if args[0] != nil {
94	-	arg0 = args[0].(context.Context)
95	-	}
96	-	var arg1 domain.Principal
97	-	if args[1] != nil {
98	-	arg1 = args[1].(domain.Principal)
99	-	}
100	-	var arg2 app.CreateTokenParams
101	-	if args[2] != nil {
102	-	arg2 = args[2].(app.CreateTokenParams)
103	-	}
104	-	run(
105	-	arg0,
106	-	arg1,
107	-	arg2,
108	-	)
109	-	})
110	-	return _c
111	-	}
112	-
113	-	func (_c Tokens_Create_Call) Return(createdToken app.CreatedToken, err error) Tokens_Create_Call {
114	-	_c.Call.Return(createdToken, err)
115	-	return _c
116	-	}
117	-
118	-	func (_c Tokens_Create_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, params app.CreateTokenParams) (app.CreatedToken, error)) Tokens_Create_Call {
119	-	_c.Call.Return(run)
120	-	return _c
121	-	}
122	-
123	-	// ListPage provides a mock function for the type Tokens
124	-	func (_mock *Tokens) ListPage(ctx context.Context, p domain.Principal, size int, token string) (app.TokenPage, error) {
125	-	ret := _mock.Called(ctx, p, size, token)
126	-
127	-	if len(ret) == 0 {
128	-	panic("no return value specified for ListPage")
129	-	}
130	-
131	-	var r0 app.TokenPage
132	-	var r1 error
133	-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, int, string) (app.TokenPage, error)); ok {
134	-	return returnFunc(ctx, p, size, token)
135	-	}
136	-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, int, string) app.TokenPage); ok {
137	-	r0 = returnFunc(ctx, p, size, token)
138	-	} else {
139	-	r0 = ret.Get(0).(app.TokenPage)
140	-	}
141	-	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, int, string) error); ok {
142	-	r1 = returnFunc(ctx, p, size, token)
143	-	} else {
144	-	r1 = ret.Error(1)
145	-	}
146	-	return r0, r1
147	-	}
148	-
149	-	// Tokens_ListPage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPage'
150	-	type Tokens_ListPage_Call struct {
151	-	*mock.Call
152	-	}
153	-
154	-	// ListPage is a helper method to define mock.On call
155	-	// - ctx context.Context
156	-	// - p domain.Principal
157	-	// - size int
158	-	// - token string
159	-	func (_e Tokens_Expecter) ListPage(ctx any, p any, size any, token any) Tokens_ListPage_Call {
160	-	return &Tokens_ListPage_Call{Call: _e.mock.On("ListPage", ctx, p, size, token)}
161	-	}
162	-
163	-	func (_c Tokens_ListPage_Call) Run(run func(ctx context.Context, p domain.Principal, size int, token string)) Tokens_ListPage_Call {
164	-	_c.Call.Run(func(args mock.Arguments) {
165	-	var arg0 context.Context
166	-	if args[0] != nil {
167	-	arg0 = args[0].(context.Context)
168	-	}
169	-	var arg1 domain.Principal
170	-	if args[1] != nil {
171	-	arg1 = args[1].(domain.Principal)
172	-	}
173	-	var arg2 int
174	-	if args[2] != nil {
175	-	arg2 = args[2].(int)
176	-	}
177	-	var arg3 string
178	-	if args[3] != nil {
179	-	arg3 = args[3].(string)
180	-	}
181	-	run(
182	-	arg0,
183	-	arg1,
184	-	arg2,
185	-	arg3,
186	-	)
187	-	})
188	-	return _c
189	-	}
190	-
191	-	func (_c Tokens_ListPage_Call) Return(tokenPage app.TokenPage, err error) Tokens_ListPage_Call {
192	-	_c.Call.Return(tokenPage, err)
193	-	return _c
194	-	}
195	-
196	-	func (_c Tokens_ListPage_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, size int, token string) (app.TokenPage, error)) Tokens_ListPage_Call {
197	-	_c.Call.Return(run)
198	-	return _c
199	-	}
200	-
201	-	// Revoke provides a mock function for the type Tokens
202	-	func (_mock *Tokens) Revoke(ctx context.Context, p domain.Principal, id string) error {
203	-	ret := _mock.Called(ctx, p, id)
204	-
205	-	if len(ret) == 0 {
206	-	panic("no return value specified for Revoke")
207	-	}
208	-
209	-	var r0 error
210	-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, string) error); ok {
211	-	r0 = returnFunc(ctx, p, id)
212	-	} else {
213	-	r0 = ret.Error(0)
214	-	}
215	-	return r0
216	-	}
217	-
218	-	// Tokens_Revoke_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Revoke'
219	-	type Tokens_Revoke_Call struct {
220	-	*mock.Call
221	-	}
222	-
223	-	// Revoke is a helper method to define mock.On call
224	-	// - ctx context.Context
225	-	// - p domain.Principal
226	-	// - id string
227	-	func (_e Tokens_Expecter) Revoke(ctx any, p any, id any) Tokens_Revoke_Call {
228	-	return &Tokens_Revoke_Call{Call: _e.mock.On("Revoke", ctx, p, id)}
229	-	}
230	-
231	-	func (_c Tokens_Revoke_Call) Run(run func(ctx context.Context, p domain.Principal, id string)) Tokens_Revoke_Call {
232	-	_c.Call.Run(func(args mock.Arguments) {
233	-	var arg0 context.Context
234	-	if args[0] != nil {
235	-	arg0 = args[0].(context.Context)
236	-	}
237	-	var arg1 domain.Principal
238	-	if args[1] != nil {
239	-	arg1 = args[1].(domain.Principal)
240	-	}
241	-	var arg2 string
242	-	if args[2] != nil {
243	-	arg2 = args[2].(string)
244	-	}
245	-	run(
246	-	arg0,
247	-	arg1,
248	-	arg2,
249	-	)
250	-	})
251	-	return _c
252	-	}
253	-
254	-	func (_c Tokens_Revoke_Call) Return(err error) Tokens_Revoke_Call {
255	-	_c.Call.Return(err)
256	-	return _c
257	-	}
258	-
259	-	func (_c Tokens_Revoke_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, id string) error) Tokens_Revoke_Call {
260	-	_c.Call.Return(run)
261	-	return _c
262	-	}

M internal/adapters/rpc/repo.go +6 -6

 	"connectrpc.com/connect"
 	pb "bnema.dev/ermite-api/gen/ermite"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // repoService implements ermiteconnect.RepoServiceHandler.
-type repoService struct{ repos Repos }
+type repoService struct{ repos ports.RepoService }
 func (s *repoService) ListRepos(ctx context.Context, req *connect.Request[pb.ListReposRequest]) (*connect.Response[pb.ListReposResponse], error) {
 	page, err := s.repos.ListPage(ctx, caller(ctx), int(req.Msg.GetPageSize()), req.Msg.GetPageToken())
 	if err != nil {
 		return nil, connectError(ctx, err)
 	}
-	repo, err := s.repos.Create(ctx, caller(ctx), app.CreateParams{
+	repo, err := s.repos.Create(ctx, caller(ctx), ports.CreateRepoParams{
 		Name: name, Description: req.Msg.GetDescription(), Visibility: vis,
 	})
 	if err != nil {
 // nothing else.
 //
 //hexcheck:ignore suspicious-business-logic-in-adapter maps the field mask of the contract to the optional fields of the use case; no rule is decided here
-func updateParams(msg *pb.UpdateRepoRequest) (app.UpdateParams, error) {
+func updateParams(msg *pb.UpdateRepoRequest) (ports.UpdateRepoParams, error) {
-	var params app.UpdateParams
+	var params ports.UpdateRepoParams
 	paths := msg.GetUpdateMask().GetPaths()
 	if len(paths) == 0 {
 		return params, fmt.Errorf("%w: update_mask is empty", domain.ErrInvalid)
 }
 // respondRepo adds the default branch to repo and wraps it in a response.
-func respondRepo[T any](ctx context.Context, repos Repos, repo domain.Repo, wrap func(*pb.Repo) *T) (*connect.Response[T], error) {
+func respondRepo[T any](ctx context.Context, repos ports.RepoService, repo domain.Repo, wrap func(*pb.Repo) *T) (*connect.Response[T], error) {
 	view, err := repos.View(ctx, repo)
 	if err != nil {
 		return nil, connectError(ctx, err)

M internal/adapters/rpc/repo_test.go +16 -16

 	"google.golang.org/protobuf/types/known/fieldmaskpb"
 	pb "bnema.dev/ermite-api/gen/ermite"
-	"bnema.dev/ermite/internal/adapters/rpc/mocks"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
+	"bnema.dev/ermite/internal/ports/mocks"
 )
 // ownerCtx is the context of a call made by the owner, as the interceptor
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			repos := mocks.NewRepos(t)
+			repos := mocks.NewRepoService(t)
 			if tt.wantCall {
 				repo := domain.Repo{Name: mustRepoName(t, "demo"), Description: "d", Visibility: domain.VisibilityPublic}
 				repos.EXPECT().Get(mock.Anything, domain.Owner(), repo.Name).Return(repo, tt.usecase).Once()
 				if tt.usecase == nil {
-					repos.EXPECT().View(mock.Anything, repo).Return(app.RepoView{Repo: repo, DefaultBranch: "main"}, tt.viewErr).Once()
+					repos.EXPECT().View(mock.Anything, repo).Return(ports.RepoView{Repo: repo, DefaultBranch: "main"}, tt.viewErr).Once()
 				}
 			}
 			svc := &repoService{repos}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			repos := mocks.NewRepos(t)
+			repos := mocks.NewRepoService(t)
 			if tt.wantCall {
 				repo := domain.Repo{Name: mustRepoName(t, "demo"), Visibility: domain.VisibilityPrivate}
-				repos.EXPECT().Create(mock.Anything, domain.Owner(), mock.MatchedBy(func(p app.CreateParams) bool {
+				repos.EXPECT().Create(mock.Anything, domain.Owner(), mock.MatchedBy(func(p ports.CreateRepoParams) bool {
 					return p.Name.String() == "demo"
 				})).Return(repo, tt.usecase).Once()
 				if tt.usecase == nil {
-					repos.EXPECT().View(mock.Anything, repo).Return(app.RepoView{Repo: repo}, nil).Once()
+					repos.EXPECT().View(mock.Anything, repo).Return(ports.RepoView{Repo: repo}, nil).Once()
 				}
 			}
 			resp, err := (&repoService{repos}).CreateRepo(ownerCtx(), connect.NewRequest(tt.req))
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			repos := mocks.NewRepos(t)
+			repos := mocks.NewRepoService(t)
 			if tt.wantCall {
 				repo := domain.Repo{Name: mustRepoName(t, "demo"), Description: "new"}
 				repos.EXPECT().Update(mock.Anything, domain.Owner(), repo.Name, mock.Anything).Return(repo, tt.usecase).Once()
 				if tt.usecase == nil {
-					repos.EXPECT().View(mock.Anything, repo).Return(app.RepoView{Repo: repo}, nil).Once()
+					repos.EXPECT().View(mock.Anything, repo).Return(ports.RepoView{Repo: repo}, nil).Once()
 				}
 			}
 			resp, err := (&repoService{repos}).UpdateRepo(ownerCtx(), connect.NewRequest(tt.req))
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			repos := mocks.NewRepos(t)
+			repos := mocks.NewRepoService(t)
 			if tt.wantCall {
 				repos.EXPECT().Delete(mock.Anything, domain.Owner(), mustRepoName(t, tt.repo)).Return(tt.usecase).Once()
 			}
 	t.Parallel()
 	t.Run("pages and views every repo", func(t *testing.T) {
 		t.Parallel()
-		repos := mocks.NewRepos(t)
+		repos := mocks.NewRepoService(t)
 		a := domain.Repo{Name: mustRepoName(t, "a")}
 		b := domain.Repo{Name: mustRepoName(t, "b")}
-		repos.EXPECT().ListPage(mock.Anything, domain.Owner(), 2, "tok").Return(app.RepoPage{Repos: []domain.Repo{a, b}, NextPageToken: "next"}, nil).Once()
+		repos.EXPECT().ListPage(mock.Anything, domain.Owner(), 2, "tok").Return(ports.RepoPage{Repos: []domain.Repo{a, b}, NextPageToken: "next"}, nil).Once()
-		repos.EXPECT().View(mock.Anything, a).Return(app.RepoView{Repo: a}, nil).Once()
+		repos.EXPECT().View(mock.Anything, a).Return(ports.RepoView{Repo: a}, nil).Once()
-		repos.EXPECT().View(mock.Anything, b).Return(app.RepoView{Repo: b}, nil).Once()
+		repos.EXPECT().View(mock.Anything, b).Return(ports.RepoView{Repo: b}, nil).Once()
 		resp, err := (&repoService{repos}).ListRepos(ownerCtx(), connect.NewRequest(&pb.ListReposRequest{PageSize: 2, PageToken: "tok"}))
 		require.NoError(t, err)
 		require.Len(t, resp.Msg.GetRepos(), 2)
 	} {
 		t.Run(name, func(t *testing.T) {
 			t.Parallel()
-			repos := mocks.NewRepos(t)
+			repos := mocks.NewRepoService(t)
-			repos.EXPECT().ListPage(mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(app.RepoPage{}, tc.err).Once()
+			repos.EXPECT().ListPage(mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(ports.RepoPage{}, tc.err).Once()
 			_, err := (&repoService{repos}).ListRepos(ownerCtx(), connect.NewRequest(&pb.ListReposRequest{}))
 			requireCode(t, tc.code, err)
 		})

M internal/adapters/rpc/server.go +2 -1

 	"connectrpc.com/connect"
 	pb "bnema.dev/ermite-api/gen/ermite"
+	"bnema.dev/ermite/internal/ports"
 )
 // serverService implements ermiteconnect.ServerServiceHandler.
 type serverService struct {
 	version string
-	key     SigningKey
+	key     ports.SigningKeyService
 }
 func (s *serverService) GetVersion(context.Context, *connect.Request[pb.GetVersionRequest]) (*connect.Response[pb.GetVersionResponse], error) {

M internal/adapters/rpc/server_test.go +3 -3

 	"github.com/stretchr/testify/require"
 	pb "bnema.dev/ermite-api/gen/ermite"
-	"bnema.dev/ermite/internal/adapters/rpc/mocks"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports/mocks"
 )
 func TestServerServiceGetVersion(t *testing.T) {
 	t.Parallel()
-	svc := &serverService{version: "v1.2.3", key: mocks.NewSigningKey(t)}
+	svc := &serverService{version: "v1.2.3", key: mocks.NewSigningKeyService(t)}
 	resp, err := svc.GetVersion(context.Background(), connect.NewRequest(&pb.GetVersionRequest{}))
 	require.NoError(t, err)
 	assert.Equal(t, "v1.2.3", resp.Msg.GetVersion())
 func TestServerServiceGetSigningKey(t *testing.T) {
 	t.Parallel()
-	key := mocks.NewSigningKey(t)
+	key := mocks.NewSigningKeyService(t)
 	key.EXPECT().Info().Return(domain.SigningKeyInfo{
 		Key:       domain.SigningPublicKey{AuthorizedKey: "ssh-ed25519 AAAA", Fingerprint: "SHA256:xyz"},
 		Committer: domain.Identity{Name: "ermite", Email: "ermite@example.com"},

D internal/adapters/rpc/services.go +0 -81

@@ -1,81 +0,0 @@
1	-	// SPDX-License-Identifier: AGPL-3.0-or-later
2	-
3	-	package rpc
4	-
5	-	import (
6	-	"context"
7	-	"io"
8	-	"time"
9	-
10	-	"bnema.dev/ermite/internal/app"
11	-	"bnema.dev/ermite/internal/domain"
12	-	)
13	-
14	-	// The interfaces below are what the handlers need of the use cases, declared
15	-	// where they are used. The types of app fit them; the mocks in rpc/mocks
16	-	// stand in for them in tests.
17	-
18	-	// Repos is the repository use cases the API serves. *app.Repos fits.
19	-	type Repos interface {
20	-	ListPage(ctx context.Context, p domain.Principal, size int, token string) (app.RepoPage, error)
21	-	View(ctx context.Context, repo domain.Repo) (app.RepoView, error)
22	-	Get(ctx context.Context, p domain.Principal, name domain.RepoName) (domain.Repo, error)
23	-	Create(ctx context.Context, p domain.Principal, params app.CreateParams) (domain.Repo, error)
24	-	Update(ctx context.Context, p domain.Principal, name domain.RepoName, params app.UpdateParams) (domain.Repo, error)
25	-	Delete(ctx context.Context, p domain.Principal, name domain.RepoName) error
26	-	}
27	-
28	-	// Tokens is the access token use cases the API serves. *app.Tokens fits.
29	-	type Tokens interface {
30	-	Create(ctx context.Context, p domain.Principal, params app.CreateTokenParams) (app.CreatedToken, error)
31	-	ListPage(ctx context.Context, p domain.Principal, size int, token string) (app.TokenPage, error)
32	-	Revoke(ctx context.Context, p domain.Principal, id string) error
33	-	}
34	-
35	-	// Browse is the read side of a repository's content. *app.Browse fits.
36	-	type Browse interface {
37	-	ListRefs(ctx context.Context, p domain.Principal, repo domain.RepoName, params app.ListRefsParams) (app.RefPage, error)
38	-	ResolveRevision(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision) (domain.ResolvedRevision, error)
39	-	GetTree(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision, path domain.TreePath, includeLastCommit bool) (domain.Tree, error)
40	-	OpenBlob(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision, path domain.TreePath) (domain.BlobInfo, io.ReadCloser, error)
41	-	ListCommits(ctx context.Context, p domain.Principal, repo domain.RepoName, params app.ListCommitsParams) (app.CommitPage, error)
42	-	GetCommit(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision) (domain.CommitDetail, error)
43	-	}
44	-
45	-	// Events streams the events of the forge. *app.Events fits.
46	-	type Events interface {
47	-	Watch(ctx context.Context, p domain.Principal, params app.WatchParams, send func(app.WatchEvent) error) error
48	-	}
49	-
50	-	// MergeRequests is the merge request use cases. *app.MergeRequests fits.
51	-	type MergeRequests interface {
52	-	Create(ctx context.Context, p domain.Principal, name domain.RepoName, params app.CreateMergeRequestParams) (domain.MergeRequest, error)
53	-	List(ctx context.Context, p domain.Principal, name domain.RepoName, params app.ListMergeRequestsParams) (app.MergeRequestPage, error)
54	-	Get(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, sinceLastRead bool) (app.MergeRequestDetail, error)
55	-	AddComment(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params app.AddCommentParams) (domain.Comment, error)
56	-	ResolveComment(ctx context.Context, p domain.Principal, name domain.RepoName, number, commentID int64, resolved bool) (domain.Comment, error)
57	-	Close(ctx context.Context, p domain.Principal, name domain.RepoName, number int64) (domain.MergeRequest, error)
58	-	MarkRead(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, head domain.ObjectID) (domain.ObjectID, error)
59	-	Merge(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params app.MergeParams) (app.MergeResult, error)
60	-	}
61	-
62	-	// SigningKey tells which key signs the commits of the forge. *app.SigningKey
63	-	// fits.
64	-	type SigningKey interface {
65	-	Info() domain.SigningKeyInfo
66	-	}
67	-
68	-	// Sessions is the owner's web session use cases the API serves.
69	-	// *app.Sessions fits.
70	-	type Sessions interface {
71	-	CreateLoginLink(ctx context.Context, p domain.Principal) (app.LoginLink, error)
72	-	SignOutEverywhere(ctx context.Context, p domain.Principal) error
73	-	}
74	-
75	-	// FailureLimiter counts the failed authentications per client. It is shared
76	-	// with the other adapters that authenticate, so that a client has one budget
77	-	// of failures. *clientlimit.Limiter fits.
78	-	type FailureLimiter interface {
79	-	Blocked(ctx context.Context, addr string) (bool, time.Duration)
80	-	Fail(ctx context.Context, addr string)
81	-	}

M internal/adapters/rpc/session.go +2 -1

 	"connectrpc.com/connect"
 	pb "bnema.dev/ermite-api/gen/ermite"
+	"bnema.dev/ermite/internal/ports"
 )
 // sessionService implements ermiteconnect.SessionServiceHandler. The browser
 // never calls it: sessions come from the link, and the API ignores cookies.
-type sessionService struct{ sessions Sessions }
+type sessionService struct{ sessions ports.SessionService }
 func (s *sessionService) CreateLoginLink(ctx context.Context, _ *connect.Request[pb.CreateLoginLinkRequest]) (*connect.Response[pb.CreateLoginLinkResponse], error) {
 	link, err := s.sessions.CreateLoginLink(ctx, caller(ctx))

M internal/adapters/rpc/session_test.go +5 -5

 	"github.com/stretchr/testify/require"
 	pb "bnema.dev/ermite-api/gen/ermite"
-	"bnema.dev/ermite/internal/adapters/rpc/mocks"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
+	"bnema.dev/ermite/internal/ports/mocks"
 )
 func TestSessionServiceCreateLoginLink(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			sessions := mocks.NewSessions(t)
+			sessions := mocks.NewSessionService(t)
 			sessions.EXPECT().CreateLoginLink(mock.Anything, domain.Owner()).
-				Return(app.LoginLink{URL: "https://x/-/login/n", ExpiresAt: exp}, tt.usecase).Once()
+				Return(ports.LoginLink{URL: "https://x/-/login/n", ExpiresAt: exp}, tt.usecase).Once()
 			resp, err := (&sessionService{sessions}).CreateLoginLink(ownerCtx(), connect.NewRequest(&pb.CreateLoginLinkRequest{}))
 			if tt.wantCode != 0 {
 				requireCode(t, tt.wantCode, err)
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			sessions := mocks.NewSessions(t)
+			sessions := mocks.NewSessionService(t)
 			sessions.EXPECT().SignOutEverywhere(mock.Anything, domain.Owner()).Return(tt.usecase).Once()
 			_, err := (&sessionService{sessions}).SignOutEverywhere(ownerCtx(), connect.NewRequest(&pb.SignOutEverywhereRequest{}))
 			if tt.wantCode != 0 {

M internal/adapters/rpc/token.go +3 -3

 	"connectrpc.com/connect"
 	pb "bnema.dev/ermite-api/gen/ermite"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // tokenService implements ermiteconnect.TokenServiceHandler.
-type tokenService struct{ tokens Tokens }
+type tokenService struct{ tokens ports.TokenService }
 func (s *tokenService) CreateToken(ctx context.Context, req *connect.Request[pb.CreateTokenRequest]) (*connect.Response[pb.CreateTokenResponse], error) {
-	params := app.CreateTokenParams{
+	params := ports.CreateTokenParams{
 		Label:     req.Msg.GetLabel(),
 		ExpiresAt: goTime(req.Msg.GetExpiresAt()),
 	}

M internal/adapters/rpc/token_test.go +11 -11

 	"github.com/stretchr/testify/require"
 	pb "bnema.dev/ermite-api/gen/ermite"
-	"bnema.dev/ermite/internal/adapters/rpc/mocks"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
+	"bnema.dev/ermite/internal/ports/mocks"
 )
 func TestTokenServiceCreateToken(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			tokens := mocks.NewTokens(t)
+			tokens := mocks.NewTokenService(t)
 			if tt.wantCall {
 				tokens.EXPECT().Create(mock.Anything, domain.Owner(), mock.Anything).
-					Return(app.CreatedToken{Token: domain.Token{ID: "t1", Label: "ci"}, Secret: "s3cret"}, tt.usecase).Once()
+					Return(ports.CreatedToken{Token: domain.Token{ID: "t1", Label: "ci"}, Secret: "s3cret"}, tt.usecase).Once()
 			}
 			resp, err := (&tokenService{tokens}).CreateToken(ownerCtx(), connect.NewRequest(tt.req))
 			if tt.wantCode != 0 {
 func TestTokenServiceCreateTokenPassesParams(t *testing.T) {
 	t.Parallel()
-	tokens := mocks.NewTokens(t)
+	tokens := mocks.NewTokenService(t)
-	tokens.EXPECT().Create(mock.Anything, domain.Owner(), mock.MatchedBy(func(p app.CreateTokenParams) bool {
+	tokens.EXPECT().Create(mock.Anything, domain.Owner(), mock.MatchedBy(func(p ports.CreateTokenParams) bool {
 		return p.Label == "ci" && len(p.Scopes) == 1 && len(p.Repos) == 1 && p.Repos[0].String() == "demo"
-	})).Return(app.CreatedToken{}, nil).Once()
+	})).Return(ports.CreatedToken{}, nil).Once()
 	_, err := (&tokenService{tokens}).CreateToken(ownerCtx(), connect.NewRequest(&pb.CreateTokenRequest{
 		Label: "ci", Scopes: []pb.Scope{pb.Scope_SCOPE_REPO_READ}, Repos: []string{"demo"},
 	}))
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			t.Parallel()
-			tokens := mocks.NewTokens(t)
+			tokens := mocks.NewTokenService(t)
 			tokens.EXPECT().Revoke(mock.Anything, domain.Owner(), "t1").Return(tt.usecase).Once()
 			_, err := (&tokenService{tokens}).RevokeToken(ownerCtx(), connect.NewRequest(&pb.RevokeTokenRequest{Id: "t1"}))
 			if tt.wantCode != 0 {
 func TestTokenServiceListTokens(t *testing.T) {
 	t.Parallel()
-	tokens := mocks.NewTokens(t)
+	tokens := mocks.NewTokenService(t)
 	tokens.EXPECT().ListPage(mock.Anything, domain.Owner(), 5, "tok").
-		Return(app.TokenPage{Tokens: []domain.Token{{ID: "a"}, {ID: "b"}}, NextPageToken: "n"}, nil).Once()
+		Return(ports.TokenPage{Tokens: []domain.Token{{ID: "a"}, {ID: "b"}}, NextPageToken: "n"}, nil).Once()
 	resp, err := (&tokenService{tokens}).ListTokens(ownerCtx(), connect.NewRequest(&pb.ListTokensRequest{PageSize: 5, PageToken: "tok"}))
 	require.NoError(t, err)
 	assert.Len(t, resp.Msg.GetTokens(), 2)
 	assert.Equal(t, "n", resp.Msg.GetNextPageToken())
-	tokens.EXPECT().ListPage(mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(app.TokenPage{}, domain.ErrInvalidPageToken).Once()
+	tokens.EXPECT().ListPage(mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(ports.TokenPage{}, domain.ErrInvalidPageToken).Once()
 	_, err = (&tokenService{tokens}).ListTokens(ownerCtx(), connect.NewRequest(&pb.ListTokensRequest{}))
 	requireCode(t, connect.CodeInvalidArgument, err)
 }

M internal/adapters/web/events_test.go +6 -5

 	pb "bnema.dev/ermite-api/gen/ermite"
 	"bnema.dev/ermite-api/gen/ermite/ermiteconnect"
-	"bnema.dev/ermite/internal/adapters/web/mocks"
+	"bnema.dev/ermite/internal/ports"
+	"bnema.dev/ermite/internal/ports/mocks"
 )
 func TestFormatEvent(t *testing.T) {
 }
 // eventsServerWith is eventsServer with sessions, when sess is not nil.
-func eventsServerWith(t *testing.T, f *fakeEvents, beat time.Duration, writeTimeout time.Duration, sess SessionAuth) *httptest.Server {
+func eventsServerWith(t *testing.T, f *fakeEvents, beat time.Duration, writeTimeout time.Duration, sess ports.WebSessionService) *httptest.Server {
 	t.Helper()
 	api := http.NewServeMux()
 	api.Handle(ermiteconnect.NewEventServiceHandler(f))
 	}
 }
-func limiterFor(sess SessionAuth) FailureLimiter {
+func limiterFor(sess ports.WebSessionService) ports.FailureLimiter {
 	if sess == nil {
 		return nil
 	}
 	return &countingLimiter{}
 }
-// newRevocable is a SessionAuth whose one session ends when the test sets
+// newRevocable is a ports.WebSessionService whose one session ends when the test sets
 // ended, like SignOutEverywhere does.
-func newRevocable(t *testing.T, valid string) (*mocks.SessionAuth, *atomic.Bool) {
+func newRevocable(t *testing.T, valid string) (*mocks.WebSessionService, *atomic.Bool) {
 	t.Helper()
 	var ended atomic.Bool
 	return newVerifier(t, valid, func(tok string) (bool, error) { return tok == valid && !ended.Load(), nil }), &ended

D internal/adapters/web/mocks/FailureLimiter.go +0 -160

@@ -1,160 +0,0 @@
1	-	// Code generated by mockery; DO NOT EDIT.
2	-	// github.com/vektra/mockery
3	-	// template: testify
4	-
5	-	package mocks
6	-
7	-	import (
8	-	"context"
9	-	"time"
10	-
11	-	mock "github.com/stretchr/testify/mock"
12	-	)
13	-
14	-	// NewFailureLimiter creates a new instance of FailureLimiter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15	-	// The first argument is typically a *testing.T value.
16	-	func NewFailureLimiter(t interface {
17	-	mock.TestingT
18	-	Cleanup(func())
19	-	}) *FailureLimiter {
20	-	if helper, ok := t.(interface{ Helper() }); ok {
21	-	helper.Helper()
22	-	}
23	-
24	-	mock := &FailureLimiter{}
25	-	mock.Mock.Test(t)
26	-
27	-	t.Cleanup(func() {
28	-	if helper, ok := t.(interface{ Helper() }); ok {
29	-	helper.Helper()
30	-	}
31	-	mock.AssertExpectations(t)
32	-	})
33	-
34	-	return mock
35	-	}
36	-
37	-	// FailureLimiter is an autogenerated mock type for the FailureLimiter type
38	-	type FailureLimiter struct {
39	-	mock.Mock
40	-	}
41	-
42	-	type FailureLimiter_Expecter struct {
43	-	mock *mock.Mock
44	-	}
45	-
46	-	func (_m FailureLimiter) EXPECT() FailureLimiter_Expecter {
47	-	return &FailureLimiter_Expecter{mock: &_m.Mock}
48	-	}
49	-
50	-	// Blocked provides a mock function for the type FailureLimiter
51	-	func (_mock *FailureLimiter) Blocked(ctx context.Context, addr string) (bool, time.Duration) {
52	-	ret := _mock.Called(ctx, addr)
53	-
54	-	if len(ret) == 0 {
55	-	panic("no return value specified for Blocked")
56	-	}
57	-
58	-	var r0 bool
59	-	var r1 time.Duration
60	-	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (bool, time.Duration)); ok {
61	-	return returnFunc(ctx, addr)
62	-	}
63	-	if returnFunc, ok := ret.Get(0).(func(context.Context, string) bool); ok {
64	-	r0 = returnFunc(ctx, addr)
65	-	} else {
66	-	r0 = ret.Get(0).(bool)
67	-	}
68	-	if returnFunc, ok := ret.Get(1).(func(context.Context, string) time.Duration); ok {
69	-	r1 = returnFunc(ctx, addr)
70	-	} else {
71	-	r1 = ret.Get(1).(time.Duration)
72	-	}
73	-	return r0, r1
74	-	}
75	-
76	-	// FailureLimiter_Blocked_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Blocked'
77	-	type FailureLimiter_Blocked_Call struct {
78	-	*mock.Call
79	-	}
80	-
81	-	// Blocked is a helper method to define mock.On call
82	-	// - ctx context.Context
83	-	// - addr string
84	-	func (_e FailureLimiter_Expecter) Blocked(ctx any, addr any) FailureLimiter_Blocked_Call {
85	-	return &FailureLimiter_Blocked_Call{Call: _e.mock.On("Blocked", ctx, addr)}
86	-	}
87	-
88	-	func (_c FailureLimiter_Blocked_Call) Run(run func(ctx context.Context, addr string)) FailureLimiter_Blocked_Call {
89	-	_c.Call.Run(func(args mock.Arguments) {
90	-	var arg0 context.Context
91	-	if args[0] != nil {
92	-	arg0 = args[0].(context.Context)
93	-	}
94	-	var arg1 string
95	-	if args[1] != nil {
96	-	arg1 = args[1].(string)
97	-	}
98	-	run(
99	-	arg0,
100	-	arg1,
101	-	)
102	-	})
103	-	return _c
104	-	}
105	-
106	-	func (_c FailureLimiter_Blocked_Call) Return(b bool, duration time.Duration) FailureLimiter_Blocked_Call {
107	-	_c.Call.Return(b, duration)
108	-	return _c
109	-	}
110	-
111	-	func (_c FailureLimiter_Blocked_Call) RunAndReturn(run func(ctx context.Context, addr string) (bool, time.Duration)) FailureLimiter_Blocked_Call {
112	-	_c.Call.Return(run)
113	-	return _c
114	-	}
115	-
116	-	// Fail provides a mock function for the type FailureLimiter
117	-	func (_mock *FailureLimiter) Fail(ctx context.Context, addr string) {
118	-	_mock.Called(ctx, addr)
119	-	return
120	-	}
121	-
122	-	// FailureLimiter_Fail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Fail'
123	-	type FailureLimiter_Fail_Call struct {
124	-	*mock.Call
125	-	}
126	-
127	-	// Fail is a helper method to define mock.On call
128	-	// - ctx context.Context
129	-	// - addr string
130	-	func (_e FailureLimiter_Expecter) Fail(ctx any, addr any) FailureLimiter_Fail_Call {
131	-	return &FailureLimiter_Fail_Call{Call: _e.mock.On("Fail", ctx, addr)}
132	-	}
133	-
134	-	func (_c FailureLimiter_Fail_Call) Run(run func(ctx context.Context, addr string)) FailureLimiter_Fail_Call {
135	-	_c.Call.Run(func(args mock.Arguments) {
136	-	var arg0 context.Context
137	-	if args[0] != nil {
138	-	arg0 = args[0].(context.Context)
139	-	}
140	-	var arg1 string
141	-	if args[1] != nil {
142	-	arg1 = args[1].(string)
143	-	}
144	-	run(
145	-	arg0,
146	-	arg1,
147	-	)
148	-	})
149	-	return _c
150	-	}
151	-
152	-	func (_c FailureLimiter_Fail_Call) Return() FailureLimiter_Fail_Call {
153	-	_c.Call.Return()
154	-	return _c
155	-	}
156	-
157	-	func (_c FailureLimiter_Fail_Call) RunAndReturn(run func(ctx context.Context, addr string)) FailureLimiter_Fail_Call {
158	-	_c.Run(run)
159	-	return _c
160	-	}

M internal/adapters/web/session.go +3 -27

 	"github.com/bnema/zerowrap"
 	"bnema.dev/ermite/internal/clientlimit"
+	"bnema.dev/ermite/internal/ports"
 )
 // The owner's session on the web (ADR 0018).
 // loginPrefix is the path of login links, up to the nonce.
 const loginPrefix = "/-/login/"
-// ErrLinkRejected is what SessionAuth.Login returns for a link that is
-// unknown, expired or already used.
-var ErrLinkRejected = errors.New("login link rejected")
-// SessionAuth is the session side of the use cases, as the web needs it.
-type SessionAuth interface {
-	// LoginLinkValid reports whether the link is pending, without using it.
-	LoginLinkValid(nonce string) bool
-	// Login uses the link and returns the session token and how long it
-	// lasts, or ErrLinkRejected.
-	Login(ctx context.Context, nonce string) (token string, lifetime time.Duration, err error)
-	// Verify checks a session token. When it is valid it returns the context
-	// to serve the request with, which carries the owner as the caller of the
-	// API; when it is not, ok is false and err nil. An error means the check
-	// could not be made (the request then runs as anonymous).
-	Verify(ctx context.Context, token string) (owner context.Context, ok bool, err error)
-}
-// FailureLimiter counts failed logins per client, with the failed
-// authentications of the other routes. *clientlimit.Limiter fits.
-type FailureLimiter interface {
-	Blocked(ctx context.Context, addr string) (bool, time.Duration)
-	Fail(ctx context.Context, addr string)
-}
 type signedInKey struct{}
 // SignedIn reports whether the request carries a valid owner session. The
 	nonce := r.PathValue("nonce")
 	var token string
 	var lifetime time.Duration
-	err := ErrLinkRejected
+	err := ports.ErrLinkRejected
 	if validNonce(nonce) {
 		token, lifetime, err = s.cfg.Sessions.Login(ctx, nonce)
 	}
 	switch {
-	case errors.Is(err, ErrLinkRejected):
+	case errors.Is(err, ports.ErrLinkRejected):
 		s.cfg.Limiter.Fail(ctx, addr)
 		s.secretPage(w, r, http.StatusNotFound, s.loginRejectedPage())
 		return

M internal/adapters/web/session_test.go +13 -12

 	"github.com/stretchr/testify/require"
 	"bnema.dev/ermite-api/gen/ermite/ermiteconnect"
-	"bnema.dev/ermite/internal/adapters/web/mocks"
+	"bnema.dev/ermite/internal/ports"
+	"bnema.dev/ermite/internal/ports/mocks"
 )
 // nonceA is the one valid login link of the mocks.
 var nonceA = strings.Repeat("a", 43)
-// newVerifier is a SessionAuth that accepts the session token valid, checked
+// newVerifier is a WebSessionService that accepts the session token valid, checked
 // by verify when it is not nil, and that does not know any login link. A
 // call that is not expected fails the test.
-func newVerifier(t *testing.T, valid string, verify func(token string) (bool, error)) *mocks.SessionAuth {
+func newVerifier(t *testing.T, valid string, verify func(token string) (bool, error)) *mocks.WebSessionService {
 	t.Helper()
 	if verify == nil {
 		verify = func(token string) (bool, error) { return token == valid, nil }
 	}
-	m := mocks.NewSessionAuth(t)
+	m := mocks.NewWebSessionService(t)
 	m.EXPECT().Verify(mock.Anything, mock.Anything).RunAndReturn(
 		func(ctx context.Context, token string) (context.Context, bool, error) {
 			ok, err := verify(token)
 }
 // expectLogin makes nonceA the one link of m, answering with the token valid.
-func expectLogin(m *mocks.SessionAuth, valid string) {
+func expectLogin(m *mocks.WebSessionService, valid string) {
 	m.EXPECT().LoginLinkValid(mock.Anything).RunAndReturn(func(n string) bool { return n == nonceA }).Maybe()
 	m.EXPECT().Login(mock.Anything, nonceA).Return(valid, time.Hour, nil).Maybe()
-	m.EXPECT().Login(mock.Anything, mock.Anything).Return("", time.Duration(0), ErrLinkRejected).Maybe()
+	m.EXPECT().Login(mock.Anything, mock.Anything).Return("", time.Duration(0), ports.ErrLinkRejected).Maybe()
 }
-// newSessions is a SessionAuth with one session token and one login link.
+// newSessions is a WebSessionService with one session token and one login link.
-func newSessions(t *testing.T, valid string) *mocks.SessionAuth {
+func newSessions(t *testing.T, valid string) *mocks.WebSessionService {
 	t.Helper()
 	m := newVerifier(t, valid, nil)
 	expectLogin(m, valid)
 	return m
 }
-// newBrokenSessions is a SessionAuth whose check cannot be made.
+// newBrokenSessions is a WebSessionService whose check cannot be made.
-func newBrokenSessions(t *testing.T, valid string) *mocks.SessionAuth {
+func newBrokenSessions(t *testing.T, valid string) *mocks.WebSessionService {
 	t.Helper()
 	m := newVerifier(t, valid, func(string) (bool, error) { return false, errors.New("kv down") })
 	expectLogin(m, valid)
 func (*countingLimiter) Blocked(context.Context, string) (bool, time.Duration) { return false, 0 }
 func (l *countingLimiter) Fail(context.Context, string)                        { l.fails++ }
-func newSessionServer(t *testing.T, sess SessionAuth, publicURL string) (*Server, *countingLimiter) {
+func newSessionServer(t *testing.T, sess ports.WebSessionService, publicURL string) (*Server, *countingLimiter) {
 	t.Helper()
 	lim := &countingLimiter{}
 	srv, err := New(Config{
 	_, err = New(Config{
 		Repos: failing{}, Git: ermiteconnect.NewGitServiceClient(http.DefaultClient, "http://unused.invalid"),
-		PublicURL: "https://forge.example", Sessions: mocks.NewSessionAuth(t),
+		PublicURL: "https://forge.example", Sessions: mocks.NewWebSessionService(t),
 	})
 	assert.Error(t, err, "sessions need a limiter")
 }

M internal/adapters/web/web.go +3 -2

 	"github.com/bnema/zerowrap"
 	"bnema.dev/ermite-api/gen/ermite/ermiteconnect"
+	"bnema.dev/ermite/internal/ports"
 )
 // Patterns are the ServeMux patterns the handler serves: everything. The
 	Now func() time.Time
 	// Sessions signs the owner in (ADR 0018). Without it there are no login
 	// routes and every visitor is anonymous.
-	Sessions SessionAuth
+	Sessions ports.WebSessionService
 	// Limiter counts the failed logins; required with Sessions. Share it with
 	// the API and Git, so that a client has one budget of failures.
-	Limiter FailureLimiter
+	Limiter ports.FailureLimiter
 	// TrustedProxies are the networks allowed to set X-Forwarded-For, to find
 	// the address of the client that fails a login.
 	TrustedProxies []netip.Prefix

M internal/app/browse.go +15 -52

 	history *historyCache
 }
+var _ ports.BrowseService = (*Browse)(nil)
 // NewBrowse builds the read use cases over their ports, with a history cache
 // of the default bounds.
 func NewBrowse(meta ports.RepoMetaStore, reader ports.RepoReader) *Browse {
 	return r.CreatedAt.UnixNano()
 }
-// ListRefsParams selects the refs to list.
-type ListRefsParams struct {
-	// Kinds restricts the result; empty means every kind.
-	Kinds []domain.RefKind
-	// PageSize is 0 for the default, and lowered to MaxRefPageSize.
-	PageSize int
-	// PageToken is the NextPageToken of the previous page, or empty.
-	PageToken string
-}
-// RefPage is a page of refs.
-type RefPage struct {
-	Refs []domain.Ref
-	// NextPageToken is empty on the last page.
-	NextPageToken string
-}
 func kindRank(k domain.RefKind) int {
 	switch k {
 	case domain.RefKindHead:
 // ListRefs lists HEAD, the branches and the tags, in that order, then by
 // name. The page token names the last ref of the previous page, so refs that
 // appear or disappear between two pages never shift the others.
-func (b *Browse) ListRefs(ctx context.Context, p domain.Principal, repo domain.RepoName, params ListRefsParams) (RefPage, error) {
+func (b *Browse) ListRefs(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.ListRefsParams) (ports.RefPage, error) {
 	size, err := pageSizeUpTo(params.PageSize, MaxRefPageSize)
 	if err != nil {
-		return RefPage{}, err
+		return ports.RefPage{}, err
 	}
 	for _, k := range params.Kinds {
 		if k != domain.RefKindHead && k != domain.RefKindBranch && k != domain.RefKindTag {
-			return RefPage{}, fmt.Errorf("%w: %q", domain.ErrInvalidRefKind, k)
+			return ports.RefPage{}, fmt.Errorf("%w: %q", domain.ErrInvalidRefKind, k)
 		}
 	}
 	after, err := decodeRefToken(params.PageToken)
 	if err != nil {
-		return RefPage{}, err
+		return ports.RefPage{}, err
 	}
 	if _, err := b.authorize(ctx, p, repo); err != nil {
-		return RefPage{}, err
+		return ports.RefPage{}, err
 	}
 	all, err := b.reader.ListRefs(ctx, repo)
 	if err != nil {
-		return RefPage{}, err
+		return ports.RefPage{}, err
 	}
 	var wanted []domain.Ref
 			wanted = append(wanted, r)
 		}
 	}
-	var page RefPage
+	var page ports.RefPage
 	page.Refs, page.NextPageToken = pageAfter(wanted, size,
 		func(r domain.Ref) bool { return after == nil || refAfter(r, *after) },
 		encodeRefToken)
 	return b.reader.OpenBlob(ctx, repo, rev, path)
 }
-// ListCommitsParams selects a page of history.
-type ListCommitsParams struct {
-	// Revision is where the history starts; the zero value is HEAD. Ignored
-	// when PageToken is set: the token pins the commit the first page started
-	// from, so every page walks the same history even if a branch moves.
-	Revision domain.Revision
-	// Path limits the history to the commits that changed it. It must be the
-	// same on every page of a listing.
-	Path domain.TreePath
-	// PageSize is 0 for the default, and lowered to MaxPageSize.
-	PageSize int
-	// PageToken is the NextPageToken of the previous page, or empty.
-	PageToken string
-}
-// CommitPage is a page of history, newest first.
-type CommitPage struct {
-	Commits []domain.Commit
-	// NextPageToken is empty on the last page.
-	NextPageToken string
-}
 // ListCommits returns a page of history. The page token holds the commit the
 // listing started from, how many commits were already returned and a digest
 // of the path; a token used with another path is invalid.
-func (b *Browse) ListCommits(ctx context.Context, p domain.Principal, repo domain.RepoName, params ListCommitsParams) (CommitPage, error) {
+func (b *Browse) ListCommits(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.ListCommitsParams) (ports.HistoryPage, error) {
 	size, err := pageSize(params.PageSize)
 	if err != nil {
-		return CommitPage{}, err
+		return ports.HistoryPage{}, err
 	}
 	q := ports.CommitQuery{Revision: params.Revision, Path: params.Path, Limit: size}
 	if params.PageToken != "" {
 		head, skip, err := decodeCommitToken(params.PageToken, params.Path)
 		if err != nil {
-			return CommitPage{}, err
+			return ports.HistoryPage{}, err
 		}
 		q.Revision, q.Skip = domain.RevisionOf(head), skip
 	}
 	r, err := b.authorize(ctx, p, repo)
 	if err != nil {
-		return CommitPage{}, err
+		return ports.HistoryPage{}, err
 	}
 	res, err := b.listCommits(ctx, r, q)
 	if err != nil {
-		return CommitPage{}, err
+		return ports.HistoryPage{}, err
 	}
-	out := CommitPage{Commits: res.Commits}
+	out := ports.HistoryPage{Commits: res.Commits}
 	if res.HasMore {
 		out.NextPageToken = encodeCommitToken(res.Head, q.Skip+len(res.Commits), params.Path)
 	}

M internal/app/browse_test.go +24 -24


@@ -55,7 +55,7 @@ func browseOps() []browseOp {
55		root := domain.TreePath{}	55		root := domain.TreePath{}
56		return []browseOp{	56		return []browseOp{
57		{"ListRefs", func(b *app.Browse, ctx context.Context, p domain.Principal, repo domain.RepoName) error {	57		{"ListRefs", func(b *app.Browse, ctx context.Context, p domain.Principal, repo domain.RepoName) error {
58	-	_, err := b.ListRefs(ctx, p, repo, app.ListRefsParams{})	58	+	_, err := b.ListRefs(ctx, p, repo, ports.ListRefsParams{})
59		return err	59		return err
60		}, func(r *mocks.RepoReader) { r.EXPECT().ListRefs(mock.Anything, mock.Anything).Return(nil, nil) }},	60		}, func(r *mocks.RepoReader) { r.EXPECT().ListRefs(mock.Anything, mock.Anything).Return(nil, nil) }},
61		{"ResolveRevision", func(b *app.Browse, ctx context.Context, p domain.Principal, repo domain.RepoName) error {	61		{"ResolveRevision", func(b *app.Browse, ctx context.Context, p domain.Principal, repo domain.RepoName) error {

@@ -87,7 +87,7 @@ func browseOps() []browseOp {
87		Return(domain.BlobInfo{}, io.NopCloser(strings.NewReader("")), nil)	87		Return(domain.BlobInfo{}, io.NopCloser(strings.NewReader("")), nil)
88		}},	88		}},
89		{"ListCommits", func(b *app.Browse, ctx context.Context, p domain.Principal, repo domain.RepoName) error {	89		{"ListCommits", func(b *app.Browse, ctx context.Context, p domain.Principal, repo domain.RepoName) error {
90	-	_, err := b.ListCommits(ctx, p, repo, app.ListCommitsParams{})	90	+	_, err := b.ListCommits(ctx, p, repo, ports.ListCommitsParams{})
91		return err	91		return err
92		}, func(r *mocks.RepoReader) {	92		}, func(r *mocks.RepoReader) {
93		r.EXPECT().ListCommits(mock.Anything, mock.Anything, mock.Anything).Return(ports.CommitPage{}, nil)	93		r.EXPECT().ListCommits(mock.Anything, mock.Anything, mock.Anything).Return(ports.CommitPage{}, nil)

@@ -214,7 +214,7 @@ func TestListRefsPagingAndKinds(t *testing.T) {
214		tok := ""	214		tok := ""
215		for pages := 0; ; pages++ {	215		for pages := 0; ; pages++ {
216		require.Less(t, pages, 10)	216		require.Less(t, pages, 10)
217	-	page, err := b.ListRefs(ctx, domain.Anonymous(), pub.Name, app.ListRefsParams{PageSize: 2, PageToken: tok})	217	+	page, err := b.ListRefs(ctx, domain.Anonymous(), pub.Name, ports.ListRefsParams{PageSize: 2, PageToken: tok})
218		require.NoError(t, err)	218		require.NoError(t, err)
219		got = append(got, names(page.Refs)...)	219		got = append(got, names(page.Refs)...)
220		if tok = page.NextPageToken; tok == "" {	220		if tok = page.NextPageToken; tok == "" {

@@ -226,19 +226,19 @@ func TestListRefsPagingAndKinds(t *testing.T) {
226			226
227		t.Run("a ref that appears between pages does not shift the others", func(t *testing.T) {	227		t.Run("a ref that appears between pages does not shift the others", func(t *testing.T) {
228		b := setup(t, all[:4])	228		b := setup(t, all[:4])
229	-	page, err := b.ListRefs(ctx, domain.Anonymous(), pub.Name, app.ListRefsParams{PageSize: 2})	229	+	page, err := b.ListRefs(ctx, domain.Anonymous(), pub.Name, ports.ListRefsParams{PageSize: 2})
230		require.NoError(t, err)	230		require.NoError(t, err)
231		require.Equal(t, []string{"HEAD", "refs/heads/a"}, names(page.Refs))	231		require.Equal(t, []string{"HEAD", "refs/heads/a"}, names(page.Refs))
232			232
233		b2 := setup(t, append([]domain.Ref{all[0], ref(domain.RefKindBranch, "refs/heads/0new")}, all[1:4]...))	233		b2 := setup(t, append([]domain.Ref{all[0], ref(domain.RefKindBranch, "refs/heads/0new")}, all[1:4]...))
234	-	next, err := b2.ListRefs(ctx, domain.Anonymous(), pub.Name, app.ListRefsParams{PageSize: 2, PageToken: page.NextPageToken})	234	+	next, err := b2.ListRefs(ctx, domain.Anonymous(), pub.Name, ports.ListRefsParams{PageSize: 2, PageToken: page.NextPageToken})
235		require.NoError(t, err)	235		require.NoError(t, err)
236		assert.Equal(t, []string{"refs/heads/b", "refs/heads/c"}, names(next.Refs))	236		assert.Equal(t, []string{"refs/heads/b", "refs/heads/c"}, names(next.Refs))
237		})	237		})
238			238
239		t.Run("kinds filter", func(t *testing.T) {	239		t.Run("kinds filter", func(t *testing.T) {
240		b := setup(t, all)	240		b := setup(t, all)
241	-	page, err := b.ListRefs(ctx, domain.Anonymous(), pub.Name, app.ListRefsParams{Kinds: []domain.RefKind{domain.RefKindTag}})	241	+	page, err := b.ListRefs(ctx, domain.Anonymous(), pub.Name, ports.ListRefsParams{Kinds: []domain.RefKind{domain.RefKindTag}})
242		require.NoError(t, err)	242		require.NoError(t, err)
243		assert.Equal(t, []string{"refs/tags/v1", "refs/tags/v2"}, names(page.Refs))	243		assert.Equal(t, []string{"refs/tags/v1", "refs/tags/v2"}, names(page.Refs))
244		assert.Empty(t, page.NextPageToken)	244		assert.Empty(t, page.NextPageToken)

@@ -251,13 +251,13 @@ func TestListRefsPagingAndKinds(t *testing.T) {
251		many = append(many, ref(domain.RefKindTag, fmt.Sprintf("refs/tags/t%04d", i)))	251		many = append(many, ref(domain.RefKindTag, fmt.Sprintf("refs/tags/t%04d", i)))
252		}	252		}
253		b := setup(t, many)	253		b := setup(t, many)
254	-	page, err := b.ListRefs(ctx, domain.Anonymous(), pub.Name, app.ListRefsParams{})	254	+	page, err := b.ListRefs(ctx, domain.Anonymous(), pub.Name, ports.ListRefsParams{})
255		require.NoError(t, err)	255		require.NoError(t, err)
256		assert.Len(t, page.Refs, app.DefaultPageSize)	256		assert.Len(t, page.Refs, app.DefaultPageSize)
257		assert.NotEmpty(t, page.NextPageToken)	257		assert.NotEmpty(t, page.NextPageToken)
258			258
259		b = setup(t, many)	259		b = setup(t, many)
260	-	page, err = b.ListRefs(ctx, domain.Anonymous(), pub.Name, app.ListRefsParams{PageSize: 100000})	260	+	page, err = b.ListRefs(ctx, domain.Anonymous(), pub.Name, ports.ListRefsParams{PageSize: 100000})
261		require.NoError(t, err)	261		require.NoError(t, err)
262		assert.Len(t, page.Refs, app.MaxRefPageSize, "a page holds up to MaxRefPageSize refs")	262		assert.Len(t, page.Refs, app.MaxRefPageSize, "a page holds up to MaxRefPageSize refs")
263		assert.NotEmpty(t, page.NextPageToken)	263		assert.NotEmpty(t, page.NextPageToken)

@@ -266,7 +266,7 @@ func TestListRefsPagingAndKinds(t *testing.T) {
266		t.Run("bad input never reaches the reader", func(t *testing.T) {	266		t.Run("bad input never reaches the reader", func(t *testing.T) {
267		t.Parallel()	267		t.Parallel()
268		f := newBrowseFixture(t)	268		f := newBrowseFixture(t)
269	-	for _, params := range []app.ListRefsParams{	269	+	for _, params := range []ports.ListRefsParams{
270		{PageSize: -1},	270		{PageSize: -1},
271		{Kinds: []domain.RefKind{"nope"}},	271		{Kinds: []domain.RefKind{"nope"}},
272		{PageToken: "!!!"},	272		{PageToken: "!!!"},

@@ -275,11 +275,11 @@ func TestListRefsPagingAndKinds(t *testing.T) {
275		_, err := f.browse.ListRefs(ctx, domain.Anonymous(), pub.Name, params)	275		_, err := f.browse.ListRefs(ctx, domain.Anonymous(), pub.Name, params)
276		assert.Error(t, err, "%+v", params)	276		assert.Error(t, err, "%+v", params)
277		}	277		}
278	-	_, err := f.browse.ListRefs(ctx, domain.Anonymous(), pub.Name, app.ListRefsParams{PageSize: -1})	278	+	_, err := f.browse.ListRefs(ctx, domain.Anonymous(), pub.Name, ports.ListRefsParams{PageSize: -1})
279		assert.ErrorIs(t, err, domain.ErrInvalidPageSize)	279		assert.ErrorIs(t, err, domain.ErrInvalidPageSize)
280	-	_, err = f.browse.ListRefs(ctx, domain.Anonymous(), pub.Name, app.ListRefsParams{Kinds: []domain.RefKind{"x"}})	280	+	_, err = f.browse.ListRefs(ctx, domain.Anonymous(), pub.Name, ports.ListRefsParams{Kinds: []domain.RefKind{"x"}})
281		assert.ErrorIs(t, err, domain.ErrInvalidRefKind)	281		assert.ErrorIs(t, err, domain.ErrInvalidRefKind)
282	-	_, err = f.browse.ListRefs(ctx, domain.Anonymous(), pub.Name, app.ListRefsParams{PageToken: "!!!"})	282	+	_, err = f.browse.ListRefs(ctx, domain.Anonymous(), pub.Name, ports.ListRefsParams{PageToken: "!!!"})
283		assert.ErrorIs(t, err, domain.ErrInvalidPageToken)	283		assert.ErrorIs(t, err, domain.ErrInvalidPageToken)
284		})	284		})
285		}	285		}

@@ -296,7 +296,7 @@ func TestListCommitsPaging(t *testing.T) {
296		f.meta.EXPECT().Get(ctx, pub.Name).Return(pub, nil)	296		f.meta.EXPECT().Get(ctx, pub.Name).Return(pub, nil)
297		f.reader.EXPECT().ListCommits(ctx, pub.Name, ports.CommitQuery{Path: p, Limit: 10}).	297		f.reader.EXPECT().ListCommits(ctx, pub.Name, ports.CommitQuery{Path: p, Limit: 10}).
298		Return(ports.CommitPage{Head: oid("a"), Commits: []domain.Commit{{ID: oid("b")}}, HasMore: true}, nil)	298		Return(ports.CommitPage{Head: oid("a"), Commits: []domain.Commit{{ID: oid("b")}}, HasMore: true}, nil)
299	-	page, err := f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, app.ListCommitsParams{Path: p, PageSize: 10})	299	+	page, err := f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, ports.ListCommitsParams{Path: p, PageSize: 10})
300		require.NoError(t, err)	300		require.NoError(t, err)
301		require.Len(t, page.Commits, 1)	301		require.Len(t, page.Commits, 1)
302		require.NotEmpty(t, page.NextPageToken)	302		require.NotEmpty(t, page.NextPageToken)

@@ -308,7 +308,7 @@ func TestListCommitsPaging(t *testing.T) {
308		f.meta.EXPECT().Get(ctx, pub.Name).Return(pub, nil)	308		f.meta.EXPECT().Get(ctx, pub.Name).Return(pub, nil)
309		// The revision of the request is ignored once there is a token.	309		// The revision of the request is ignored once there is a token.
310		rev, _ := domain.ParseRevision("moved")	310		rev, _ := domain.ParseRevision("moved")
311	-	next, err := f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, app.ListCommitsParams{	311	+	next, err := f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, ports.ListCommitsParams{
312		Revision: rev, Path: p, PageSize: 10, PageToken: page.NextPageToken,	312		Revision: rev, Path: p, PageSize: 10, PageToken: page.NextPageToken,
313		})	313		})
314		require.NoError(t, err)	314		require.NoError(t, err)

@@ -322,10 +322,10 @@ func TestListCommitsPaging(t *testing.T) {
322		f.meta.EXPECT().Get(ctx, pub.Name).Return(pub, nil)	322		f.meta.EXPECT().Get(ctx, pub.Name).Return(pub, nil)
323		f.reader.EXPECT().ListCommits(ctx, pub.Name, mock.Anything).	323		f.reader.EXPECT().ListCommits(ctx, pub.Name, mock.Anything).
324		Return(ports.CommitPage{Head: oid("a"), Commits: []domain.Commit{{ID: oid("b")}}, HasMore: true}, nil)	324		Return(ports.CommitPage{Head: oid("a"), Commits: []domain.Commit{{ID: oid("b")}}, HasMore: true}, nil)
325	-	page, err := f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, app.ListCommitsParams{Path: p})	325	+	page, err := f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, ports.ListCommitsParams{Path: p})
326		require.NoError(t, err)	326		require.NoError(t, err)
327			327
328	-	for _, params := range []app.ListCommitsParams{	328	+	for _, params := range []ports.ListCommitsParams{
329		{PageToken: page.NextPageToken}, // no path	329		{PageToken: page.NextPageToken}, // no path
330		{Path: mustPath(t, "other"), PageToken: page.NextPageToken}, // another path	330		{Path: mustPath(t, "other"), PageToken: page.NextPageToken}, // another path
331		{Path: p, PageToken: "garbage"},	331		{Path: p, PageToken: "garbage"},

@@ -343,7 +343,7 @@ func TestListCommitsPaging(t *testing.T) {
343		f.meta.EXPECT().Get(ctx, pub.Name).Return(pub, nil).Maybe()	343		f.meta.EXPECT().Get(ctx, pub.Name).Return(pub, nil).Maybe()
344		f.reader.EXPECT().ListCommits(ctx, pub.Name, mock.Anything).	344		f.reader.EXPECT().ListCommits(ctx, pub.Name, mock.Anything).
345		Return(ports.CommitPage{Head: oid("a"), Commits: []domain.Commit{{ID: oid("b")}}, HasMore: true}, nil).Once()	345		Return(ports.CommitPage{Head: oid("a"), Commits: []domain.Commit{{ID: oid("b")}}, HasMore: true}, nil).Once()
346	-	page, err := f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, app.ListCommitsParams{Path: p})	346	+	page, err := f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, ports.ListCommitsParams{Path: p})
347		require.NoError(t, err)	347		require.NoError(t, err)
348		raw, err := base64.RawURLEncoding.DecodeString(page.NextPageToken)	348		raw, err := base64.RawURLEncoding.DecodeString(page.NextPageToken)
349		require.NoError(t, err)	349		require.NoError(t, err)

@@ -356,9 +356,9 @@ func TestListCommitsPaging(t *testing.T) {
356			356
357		f.reader.EXPECT().ListCommits(ctx, pub.Name, mock.MatchedBy(func(q ports.CommitQuery) bool { return q.Skip == app.MaxCommitSkip })).	357		f.reader.EXPECT().ListCommits(ctx, pub.Name, mock.MatchedBy(func(q ports.CommitQuery) bool { return q.Skip == app.MaxCommitSkip })).
358		Return(ports.CommitPage{Head: oid("a")}, nil).Once()	358		Return(ports.CommitPage{Head: oid("a")}, nil).Once()
359	-	_, err = f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, app.ListCommitsParams{Path: p, PageToken: withSkip(app.MaxCommitSkip)})	359	+	_, err = f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, ports.ListCommitsParams{Path: p, PageToken: withSkip(app.MaxCommitSkip)})
360		require.NoError(t, err, "the cap itself is allowed")	360		require.NoError(t, err, "the cap itself is allowed")
361	-	_, err = f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, app.ListCommitsParams{Path: p, PageToken: withSkip(app.MaxCommitSkip + 1)})	361	+	_, err = f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, ports.ListCommitsParams{Path: p, PageToken: withSkip(app.MaxCommitSkip + 1)})
362		assert.ErrorIs(t, err, domain.ErrInvalidPageToken)	362		assert.ErrorIs(t, err, domain.ErrInvalidPageToken)
363		})	363		})
364			364

@@ -368,11 +368,11 @@ func TestListCommitsPaging(t *testing.T) {
368		f.meta.EXPECT().Get(ctx, pub.Name).Return(pub, nil).Times(2)	368		f.meta.EXPECT().Get(ctx, pub.Name).Return(pub, nil).Times(2)
369		f.reader.EXPECT().ListCommits(ctx, pub.Name, ports.CommitQuery{Limit: app.DefaultPageSize}).Return(ports.CommitPage{}, nil)	369		f.reader.EXPECT().ListCommits(ctx, pub.Name, ports.CommitQuery{Limit: app.DefaultPageSize}).Return(ports.CommitPage{}, nil)
370		f.reader.EXPECT().ListCommits(ctx, pub.Name, ports.CommitQuery{Limit: 100}).Return(ports.CommitPage{}, nil)	370		f.reader.EXPECT().ListCommits(ctx, pub.Name, ports.CommitQuery{Limit: 100}).Return(ports.CommitPage{}, nil)
371	-	_, err := f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, app.ListCommitsParams{})	371	+	_, err := f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, ports.ListCommitsParams{})
372		require.NoError(t, err)	372		require.NoError(t, err)
373	-	_, err = f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, app.ListCommitsParams{PageSize: 5000})	373	+	_, err = f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, ports.ListCommitsParams{PageSize: 5000})
374		require.NoError(t, err)	374		require.NoError(t, err)
375	-	_, err = f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, app.ListCommitsParams{PageSize: -3})	375	+	_, err = f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, ports.ListCommitsParams{PageSize: -3})
376		assert.ErrorIs(t, err, domain.ErrInvalidPageSize)	376		assert.ErrorIs(t, err, domain.ErrInvalidPageSize)
377		})	377		})
378			378

@@ -382,10 +382,10 @@ func TestListCommitsPaging(t *testing.T) {
382		f.meta.EXPECT().Get(ctx, priv.Name).Return(priv, nil)	382		f.meta.EXPECT().Get(ctx, priv.Name).Return(priv, nil)
383		f.reader.EXPECT().ListCommits(ctx, priv.Name, mock.Anything).	383		f.reader.EXPECT().ListCommits(ctx, priv.Name, mock.Anything).
384		Return(ports.CommitPage{Head: oid("a"), Commits: []domain.Commit{{ID: oid("b")}}, HasMore: true}, nil)	384		Return(ports.CommitPage{Head: oid("a"), Commits: []domain.Commit{{ID: oid("b")}}, HasMore: true}, nil)
385	-	page, err := f.browse.ListCommits(ctx, domain.Root(), priv.Name, app.ListCommitsParams{})	385	+	page, err := f.browse.ListCommits(ctx, domain.Root(), priv.Name, ports.ListCommitsParams{})
386		require.NoError(t, err)	386		require.NoError(t, err)
387		f.meta.EXPECT().Get(ctx, priv.Name).Return(priv, nil)	387		f.meta.EXPECT().Get(ctx, priv.Name).Return(priv, nil)
388	-	_, err = f.browse.ListCommits(ctx, domain.Anonymous(), priv.Name, app.ListCommitsParams{PageToken: page.NextPageToken})	388	+	_, err = f.browse.ListCommits(ctx, domain.Anonymous(), priv.Name, ports.ListCommitsParams{PageToken: page.NextPageToken})
389		assert.ErrorIs(t, err, domain.ErrNotFound)	389		assert.ErrorIs(t, err, domain.ErrNotFound)
390		})	390		})
391		}	391		}

M internal/app/browsecache_test.go +4 -4


@@ -131,7 +131,7 @@ func TestHistoryCacheNotServedAcrossRecreate(t *testing.T) {
131		r.EXPECT().GetTree(mock.Anything, n, rev, dir, true).Return(domain.Tree{}, domain.ErrNotFound).Once()	131		r.EXPECT().GetTree(mock.Anything, n, rev, dir, true).Return(domain.Tree{}, domain.ErrNotFound).Once()
132		}},	132		}},
133		{"last change of a path", func(b *app.Browse) error {	133		{"last change of a path", func(b *app.Browse) error {
134	-	_, err := b.ListCommits(ctx, domain.Anonymous(), n, app.ListCommitsParams{Revision: rev, Path: dir, PageSize: 1})	134	+	_, err := b.ListCommits(ctx, domain.Anonymous(), n, ports.ListCommitsParams{Revision: rev, Path: dir, PageSize: 1})
135		return err	135		return err
136		}, func(r *mocks.RepoReader) {	136		}, func(r *mocks.RepoReader) {
137		q := ports.CommitQuery{Revision: rev, Path: dir, Limit: 1}	137		q := ports.CommitQuery{Revision: rev, Path: dir, Limit: 1}

@@ -305,7 +305,7 @@ func TestListCommitsLastChangeCache(t *testing.T) {
305		}, nil).Times(tc.calls)	305		}, nil).Times(tc.calls)
306		for range 2 {	306		for range 2 {
307		page, err := f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name,	307		page, err := f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name,
308	-	app.ListCommitsParams{Revision: tc.rev, Path: tc.path, PageSize: tc.size})	308	+	ports.ListCommitsParams{Revision: tc.rev, Path: tc.path, PageSize: tc.size})
309		require.NoError(t, err)	309		require.NoError(t, err)
310		require.Len(t, page.Commits, 1)	310		require.Len(t, page.Commits, 1)
311		page.Commits[0].Parents[0] = oid("f") // must not leak into the cache	311		page.Commits[0].Parents[0] = oid("f") // must not leak into the cache

@@ -319,13 +319,13 @@ func TestListCommitsLastChangeCache(t *testing.T) {
319		f.meta.EXPECT().Get(mock.Anything, pub.Name).Return(pub, nil)	319		f.meta.EXPECT().Get(mock.Anything, pub.Name).Return(pub, nil)
320		f.reader.EXPECT().ListCommits(mock.Anything, pub.Name, ports.CommitQuery{Revision: full, Path: file, Limit: 1}).	320		f.reader.EXPECT().ListCommits(mock.Anything, pub.Name, ports.CommitQuery{Revision: full, Path: file, Limit: 1}).
321		Return(ports.CommitPage{Head: oid("a"), Commits: []domain.Commit{{ID: oid("c")}}, HasMore: true}, nil).Once()	321		Return(ports.CommitPage{Head: oid("a"), Commits: []domain.Commit{{ID: oid("c")}}, HasMore: true}, nil).Once()
322	-	first, err := f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, app.ListCommitsParams{Revision: full, Path: file, PageSize: 1})	322	+	first, err := f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, ports.ListCommitsParams{Revision: full, Path: file, PageSize: 1})
323		require.NoError(t, err)	323		require.NoError(t, err)
324		require.NotEmpty(t, first.NextPageToken)	324		require.NotEmpty(t, first.NextPageToken)
325		f.reader.EXPECT().ListCommits(mock.Anything, pub.Name, ports.CommitQuery{Revision: domain.RevisionOf(oid("a")), Path: file, Skip: 1, Limit: 1}).	325		f.reader.EXPECT().ListCommits(mock.Anything, pub.Name, ports.CommitQuery{Revision: domain.RevisionOf(oid("a")), Path: file, Skip: 1, Limit: 1}).
326		Return(ports.CommitPage{Head: oid("a")}, nil).Twice()	326		Return(ports.CommitPage{Head: oid("a")}, nil).Twice()
327		for range 2 {	327		for range 2 {
328	-	_, err = f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, app.ListCommitsParams{Path: file, PageSize: 1, PageToken: first.NextPageToken})	328	+	_, err = f.browse.ListCommits(ctx, domain.Anonymous(), pub.Name, ports.ListCommitsParams{Path: file, PageSize: 1, PageToken: first.NextPageToken})
329		require.NoError(t, err)	329		require.NoError(t, err)
330		}	330		}
331		})	331		})

M internal/app/events.go +13 -45

 	// MaxWatchers is the most watches in progress at once.
 	MaxWatchers = 256
 	// MaxWatchersPerClient is the most watches in progress for one client
-	// address (see WatchParams.Client).
+	// address (see ports.WatchParams.Client).
 	MaxWatchersPerClient = 16
 	// DefaultRevalidateEvery is how long a watcher with a stored token goes
 	// without asking the token store whether the token still exists.
 // NewEvents and lives until Close.
 type Events struct {
 	repos *Repos
-	auth  Revalidator
+	auth  ports.Revalidator
 	clock ports.Clock
 	boot  string
 	size  int
 	clients map[string]int // watches in progress by client
 }
+var _ ports.EventService = (*Events)(nil)
 // EventsConfig configures Events.
 type EventsConfig struct {
 	// Size is the number of events remembered; DefaultEventBuffer when not
 	// positive.
 	Size int
 	// Auth confirms that the token of a watcher still exists. Required.
-	Auth Revalidator
+	Auth ports.Revalidator
 	// RevalidateEvery is how long the answer of Auth is kept for a watcher;
 	// DefaultRevalidateEvery when zero, and negative to ask for every event.
 	RevalidateEvery time.Duration
 	return n, err == nil && n > 0
 }
-// WatchParams select the events of a watch.
-type WatchParams struct {
-	// Topics are TopicHome or "repo:<name>"; empty means TopicHome.
-	Topics []string
-	// ResumeAfter is the id of the last event the caller saw; empty to
-	// receive only new events.
-	ResumeAfter string
-	// Client identifies where the watch comes from, for the limit per client
-	// (MaxWatchersPerClient): an opaque key such as a normalized address; the
-	// web passes its visitor's. Empty only for callers with no client, which
-	// count against MaxWatchers alone.
-	Client string
-	// Ready, when not nil, is called once the topics are valid and the watch
-	// is registered: events published from then on are not missed. Nothing is
-	// sent before it returns.
-	Ready func()
-}
-// WatchEvent is one item of a watch.
-type WatchEvent struct {
-	// ID identifies the event, for resuming. Empty on a gap.
-	ID string
-	// Gap tells that events were lost: the caller must reload what it shows.
-	// Event is nil then.
-	Gap bool
-	// Event is a domain.RepoCreated, RepoUpdated, RepoDeleted, PushEvent,
-	// MergeRequestOpened, MergeRequestMerged, MergeRequestClosed or
-	// CommentAdded.
-	Event domain.Event
-	// Repo is the state of the repository at delivery, for RepoCreated and
-	// RepoUpdated.
-	Repo *RepoView
-}
 // watch is the state of one Watch call.
 type watch struct {
 	p     domain.Principal
 // buffered, or was not issued by this run, a gap comes first and the oldest
 // buffered event follows. A watcher that falls more than the buffer behind
 // gets a gap too, and carries on with the oldest buffered event.
-func (e *Events) Watch(ctx context.Context, p domain.Principal, params WatchParams, send func(WatchEvent) error) error {
+func (e *Events) Watch(ctx context.Context, p domain.Principal, params ports.WatchParams, send func(ports.WatchEvent) error) error {
 	w, err := e.parseTopics(ctx, p, params.Topics)
 	if err != nil {
 		return err
 	log := zerowrap.FromCtx(ctx)
 	log.Debug().Strs("topics", params.Topics).Bool("resume", params.ResumeAfter != "").Bool("gap", gap).Msg("watch started")
 	if gap {
-		if err := send(WatchEvent{Gap: true}); err != nil {
+		if err := send(ports.WatchEvent{Gap: true}); err != nil {
 			return err
 		}
 	}
 		}
 		batch, changed, oldest, lost, closed := e.since(next)
 		if lost {
-			if err := send(WatchEvent{Gap: true}); err != nil {
+			if err := send(ports.WatchEvent{Gap: true}); err != nil {
 				return err
 			}
 			next = oldest
 }
 // deliver sends the event if the watcher follows its topic and may see it.
-func (e *Events) deliver(ctx context.Context, w *watch, be bufferedEvent, send func(WatchEvent) error) error {
+func (e *Events) deliver(ctx context.Context, w *watch, be bufferedEvent, send func(ports.WatchEvent) error) error {
 	if err := e.stillAllowed(ctx, w); err != nil {
 		return err
 	}
-	out := WatchEvent{ID: e.id(be.seq), Event: be.ev}
+	out := ports.WatchEvent{ID: e.id(be.seq), Event: be.ev}
 	switch ev := be.ev.(type) {
 	case domain.EventGap:
 		// The feeder lost events: tell every watcher.
-		return send(WatchEvent{Gap: true})
+		return send(ports.WatchEvent{Gap: true})
 	case domain.RepoDeleted:
 		// The repository is gone: use the visibility it had.
 		if !w.wants(ev.Repo) || !canReadAs(w.p, ev.Repo, ev.Visibility) {
 // The exception is a repository that became private: the watchers who could
 // read it before are told once, with its name and its new visibility only,
 // so that what they show can be removed.
-func (e *Events) deliverRepo(ctx context.Context, w *watch, name domain.RepoName, withRepo bool, be bufferedEvent, out WatchEvent, send func(WatchEvent) error) error {
+func (e *Events) deliverRepo(ctx context.Context, w *watch, name domain.RepoName, withRepo bool, be bufferedEvent, out ports.WatchEvent, send func(ports.WatchEvent) error) error {
 	if !w.wants(name) || !be.known {
 		return nil
 	}
 	}
 	if !canReadAs(w.p, name, be.vis) {
 		if up, ok := be.ev.(domain.RepoUpdated); ok && canReadAs(w.p, name, up.Previous) {
-			out.Repo = &RepoView{Repo: domain.Repo{Name: name, Visibility: up.Visibility}}
+			out.Repo = &ports.RepoView{Repo: domain.Repo{Name: name, Visibility: up.Visibility}}
 			return send(out)
 		}
 		return nil

M internal/app/events_test.go +60 -60

 	"github.com/stretchr/testify/require"
 	"bnema.dev/ermite/internal/app"
-	appmocks "bnema.dev/ermite/internal/app/mocks"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 	"bnema.dev/ermite/internal/ports/mocks"
 )
 	meta          *mocks.RepoMetaStore
 	git           *mocks.GitRepos
 	feed          chan domain.Event
-	auth          *appmocks.Revalidator
+	auth          *mocks.Revalidator
 	revoked       sync.Map     // token IDs revoked by the test
 	revalidations atomic.Int32 // calls to auth.Revalidate
 	events        *app.Events
 		meta: mocks.NewRepoMetaStore(t),
 		git:  mocks.NewGitRepos(t),
 		feed: make(chan domain.Event, 4096),
-		auth: appmocks.NewRevalidator(t),
+		auth: mocks.NewRevalidator(t),
 	}
 	// Tokens are valid until the test revokes them.
 	r.auth.EXPECT().Revalidate(mock.Anything, mock.Anything).RunAndReturn(func(_ context.Context, p domain.Principal) error {
 // watcher is a running Watch.
 type watcher struct {
-	got  chan app.WatchEvent
+	got  chan ports.WatchEvent
 	done chan error
 }
-func (r *eventRig) watch(ctx context.Context, p domain.Principal, params app.WatchParams) *watcher {
+func (r *eventRig) watch(ctx context.Context, p domain.Principal, params ports.WatchParams) *watcher {
-	w := &watcher{got: make(chan app.WatchEvent, 4096), done: make(chan error, 1)}
+	w := &watcher{got: make(chan ports.WatchEvent, 4096), done: make(chan error, 1)}
 	go func() {
-		w.done <- r.events.Watch(ctx, p, params, func(e app.WatchEvent) error {
+		w.done <- r.events.Watch(ctx, p, params, func(e ports.WatchEvent) error {
 			w.got <- e
 			return nil
 		})
 	return w
 }
-func (w *watcher) next(t *testing.T) app.WatchEvent {
+func (w *watcher) next(t *testing.T) ports.WatchEvent {
 	t.Helper()
 	synctest.Wait() // everything the event can reach has run
 	select {
 	default:
 		t.Fatal("no event")
 	}
-	return app.WatchEvent{}
+	return ports.WatchEvent{}
 }
 // sentinelOID marks the push events that only prove the ones before them were
 		ctx, cancel := context.WithCancel(context.Background())
 		defer cancel()
-		anon := r.watch(ctx, domain.Anonymous(), app.WatchParams{})
+		anon := r.watch(ctx, domain.Anonymous(), ports.WatchParams{})
-		root := r.watch(ctx, domain.Root(), app.WatchParams{Topics: []string{"home"}})
+		root := r.watch(ctx, domain.Root(), ports.WatchParams{Topics: []string{"home"}})
-		scoped := r.watch(ctx, tokenPrincipal(domain.ScopeRepoRead, "other"), app.WatchParams{})
+		scoped := r.watch(ctx, tokenPrincipal(domain.ScopeRepoRead, "other"), ports.WatchParams{})
-		onlyPriv := r.watch(ctx, domain.Root(), app.WatchParams{Topics: []string{"repo:priv"}})
+		onlyPriv := r.watch(ctx, domain.Root(), ports.WatchParams{Topics: []string{"repo:priv"}})
 		synctest.Wait()
 		require.Equal(t, 4, r.events.Watchers())
 		})
 		ctx, cancel := context.WithCancel(context.Background())
 		defer cancel()
-		w := r.watch(ctx, domain.Anonymous(), app.WatchParams{})
+		w := r.watch(ctx, domain.Anonymous(), ports.WatchParams{})
 		synctest.Wait()
 		require.Equal(t, 1, r.events.Watchers())
 		ctx, cancel := context.WithCancel(context.Background())
 		t.Cleanup(cancel)
-		first := r.watch(ctx, domain.Root(), app.WatchParams{})
+		first := r.watch(ctx, domain.Root(), ports.WatchParams{})
 		synctest.Wait()
 		require.Equal(t, 1, r.events.Watchers())
 		// One at a time: this watcher must not fall behind the small ring.
 			r, _, ctx, ids := setup(t)
 			// 20 events were taken, the buffer holds the last 8: ids[12] is the
 			// oldest still present; ids[0] is long gone.
-			w := r.watch(ctx, domain.Root(), app.WatchParams{ResumeAfter: ids[0]})
+			w := r.watch(ctx, domain.Root(), ports.WatchParams{ResumeAfter: ids[0]})
 			gap := w.next(t)
 			assert.True(t, gap.Gap)
 			assert.Empty(t, gap.ID)
 		synctest.Test(t, func(t *testing.T) {
 			r, _, ctx, _ := setup(t)
 			for _, id := range []string{"nonsense", "zz-1", "-", "0-0"} {
-				w := r.watch(ctx, domain.Root(), app.WatchParams{ResumeAfter: id})
+				w := r.watch(ctx, domain.Root(), ports.WatchParams{ResumeAfter: id})
 				assert.True(t, w.next(t).Gap, id)
 			}
 		})
 		t.Parallel()
 		synctest.Test(t, func(t *testing.T) {
 			r, _, ctx, _ := setup(t)
-			w := r.watch(ctx, domain.Root(), app.WatchParams{ResumeAfter: "otherboot-999"})
+			w := r.watch(ctx, domain.Root(), ports.WatchParams{ResumeAfter: "otherboot-999"})
 			assert.True(t, w.next(t).Gap)
 		})
 	})
 		t.Parallel()
 		synctest.Test(t, func(t *testing.T) {
 			r, n, ctx, ids := setup(t)
-			w := r.watch(ctx, domain.Root(), app.WatchParams{ResumeAfter: ids[16]})
+			w := r.watch(ctx, domain.Root(), ports.WatchParams{ResumeAfter: ids[16]})
 			for _, want := range ids[17:] {
 				e := w.next(t)
 				assert.False(t, e.Gap)
 		t.Parallel()
 		synctest.Test(t, func(t *testing.T) {
 			r, n, ctx, ids := setup(t)
-			w := r.watch(ctx, domain.Root(), app.WatchParams{ResumeAfter: ids[len(ids)-1]})
+			w := r.watch(ctx, domain.Root(), ports.WatchParams{ResumeAfter: ids[len(ids)-1]})
 			r.push(n, 99)
 			e := w.next(t)
 			assert.False(t, e.Gap)
 	r.repo("pub", domain.VisibilityPublic)
 	r.repo("priv", domain.VisibilityPrivate)
 	r.meta.EXPECT().Get(mock.Anything, name(t, "gone")).Return(domain.Repo{}, domain.ErrNotFound).Maybe()
-	noop := func(app.WatchEvent) error { return nil }
+	noop := func(ports.WatchEvent) error { return nil }
 	ctx := context.Background()
 	for topic, want := range map[string]error{
 		"repo:priv":    domain.ErrNotFound, // hidden from anonymous
 		"repo:pub:foo": domain.ErrInvalidName,
 	} {
-		err := r.events.Watch(ctx, domain.Anonymous(), app.WatchParams{Topics: []string{topic}}, noop)
+		err := r.events.Watch(ctx, domain.Anonymous(), ports.WatchParams{Topics: []string{topic}}, noop)
 		assert.ErrorIs(t, err, want, topic)
 	}
 }
 		synctest.Test(t, func(t *testing.T) {
 			r := newEventRig(t, 0)
 			ctx, cancel := context.WithCancel(context.Background())
-			w := r.watch(ctx, domain.Root(), app.WatchParams{})
+			w := r.watch(ctx, domain.Root(), ports.WatchParams{})
 			synctest.Wait()
 			require.Equal(t, 1, r.events.Watchers())
 			cancel()
 		t.Parallel()
 		synctest.Test(t, func(t *testing.T) {
 			r := newEventRig(t, 0)
-			w := r.watch(context.Background(), domain.Root(), app.WatchParams{})
+			w := r.watch(context.Background(), domain.Root(), ports.WatchParams{})
 			synctest.Wait()
 			require.Equal(t, 1, r.events.Watchers())
 			r.events.Close(context.Background())
 			boom := errors.New("client went away")
 			done := make(chan error, 1)
 			go func() {
-				done <- r.events.Watch(context.Background(), domain.Root(), app.WatchParams{}, func(app.WatchEvent) error { return boom })
+				done <- r.events.Watch(context.Background(), domain.Root(), ports.WatchParams{}, func(ports.WatchEvent) error { return boom })
 			}()
 			synctest.Wait()
 			require.Equal(t, 1, r.events.Watchers())
 		release := make(chan struct{})
 		var mu sync.Mutex
-		var got []app.WatchEvent
+		var got []ports.WatchEvent
 		done := make(chan error, 1)
 		blocked := make(chan struct{})
 		first := true
 		go func() {
-			done <- r.events.Watch(context.Background(), domain.Root(), app.WatchParams{}, func(e app.WatchEvent) error {
+			done <- r.events.Watch(context.Background(), domain.Root(), ports.WatchParams{}, func(e ports.WatchEvent) error {
 				if first { // block on the first event while the ring turns over
 					first = false
 					close(blocked)
 		}()
 		// A second, fast watcher tells when the use case has taken every event:
 		// it receives them in order.
-		fast := r.watch(context.Background(), domain.Root(), app.WatchParams{})
+		fast := r.watch(context.Background(), domain.Root(), ports.WatchParams{})
 		synctest.Wait()
 		require.Equal(t, 2, r.events.Watchers())
 		r.push(n, 0)
 		priv := r.repo("priv", domain.VisibilityPrivate)
 		ctx, cancel := context.WithCancel(context.Background())
 		defer cancel()
-		anon := r.watch(ctx, domain.Anonymous(), app.WatchParams{})
+		anon := r.watch(ctx, domain.Anonymous(), ports.WatchParams{})
-		root := r.watch(ctx, domain.Root(), app.WatchParams{})
+		root := r.watch(ctx, domain.Root(), ports.WatchParams{})
 		synctest.Wait()
 		require.Equal(t, 2, r.events.Watchers())
 		ctx, cancel := context.WithCancel(context.Background())
 		defer cancel()
-		w := r.watch(ctx, p, app.WatchParams{})
+		w := r.watch(ctx, p, ports.WatchParams{})
 		synctest.Wait()
 		require.Equal(t, 1, r.events.Watchers())
 		r.push(pub, 1)
 		pub := r.repo("pub", domain.VisibilityPublic)
 		// The rig's clock stands at now: this token expired at now.
 		p := tokenWith("tok", now)
-		w := r.watch(context.Background(), p, app.WatchParams{})
+		w := r.watch(context.Background(), p, ports.WatchParams{})
 		r.push(pub, 1) // whether or not the watch had started, it ends unauthenticated
 		synctest.Wait()
 		select {
 		t.Parallel()
 		synctest.Test(t, func(t *testing.T) {
 			r := newEventRigConfig(t, app.EventsConfig{}) // the production default interval
-			w := r.watch(context.Background(), tokenWith("tok", time.Time{}), app.WatchParams{})
+			w := r.watch(context.Background(), tokenWith("tok", time.Time{}), ports.WatchParams{})
 			synctest.Wait()
 			require.Equal(t, 1, r.events.Watchers())
 			r.revoked.Store("tok", true)
 		synctest.Test(t, func(t *testing.T) {
 			r := newEventRigConfig(t, app.EventsConfig{RevalidateEvery: time.Hour})
 			pub := r.repo("pub", domain.VisibilityPublic)
-			w := r.watch(context.Background(), tokenWith("tok", time.Time{}), app.WatchParams{})
+			w := r.watch(context.Background(), tokenWith("tok", time.Time{}), ports.WatchParams{})
 			synctest.Wait()
 			require.Equal(t, 1, r.events.Watchers())
 			for i := range 20 {
 		synctest.Test(t, func(t *testing.T) {
 			r := newEventRigConfig(t, app.EventsConfig{RevalidateEvery: -1})
 			pub := r.repo("pub", domain.VisibilityPublic)
-			a := r.watch(context.Background(), domain.Anonymous(), app.WatchParams{})
+			a := r.watch(context.Background(), domain.Anonymous(), ports.WatchParams{})
-			b := r.watch(context.Background(), domain.Root(), app.WatchParams{})
+			b := r.watch(context.Background(), domain.Root(), ports.WatchParams{})
 			synctest.Wait()
 			require.Equal(t, 2, r.events.Watchers())
 			r.push(pub, 1)
 func TestWatchLimits(t *testing.T) {
 	t.Parallel()
-	noop := func(app.WatchEvent) error { return nil }
+	noop := func(ports.WatchEvent) error { return nil }
 	t.Run("too many topics", func(t *testing.T) {
 		t.Parallel()
 			}
 			ctx, cancel := context.WithCancel(context.Background())
 			cancel() // returns at once once the topics are accepted
-			assert.NoError(t, r.events.Watch(ctx, domain.Root(), app.WatchParams{Topics: ok}, noop))
+			assert.NoError(t, r.events.Watch(ctx, domain.Root(), ports.WatchParams{Topics: ok}, noop))
-			err := r.events.Watch(context.Background(), domain.Root(), app.WatchParams{Topics: append(ok, "home")}, noop)
+			err := r.events.Watch(context.Background(), domain.Root(), ports.WatchParams{Topics: append(ok, "home")}, noop)
 			assert.ErrorIs(t, err, domain.ErrInvalid)
 		})
 	})
 			ctx, cancel := context.WithCancel(context.Background())
 			defer cancel()
 			for range app.MaxWatchers {
-				r.watch(ctx, domain.Root(), app.WatchParams{})
+				r.watch(ctx, domain.Root(), ports.WatchParams{})
 			}
 			synctest.Wait()
 			require.Equal(t, app.MaxWatchers, r.events.Watchers())
-			err := r.events.Watch(ctx, domain.Root(), app.WatchParams{}, noop)
+			err := r.events.Watch(ctx, domain.Root(), ports.WatchParams{}, noop)
 			assert.ErrorIs(t, err, domain.ErrResourceExhausted)
 			assert.Equal(t, app.MaxWatchers, r.events.Watchers(), "a refused watch is not counted")
 			require.Equal(t, 0, r.events.Watchers())
 			again, stop := context.WithCancel(context.Background())
 			stop()
-			assert.NoError(t, r.events.Watch(again, domain.Root(), app.WatchParams{}, noop))
+			assert.NoError(t, r.events.Watch(again, domain.Root(), ports.WatchParams{}, noop))
 		})
 	})
 			ctx, cancel := context.WithCancel(context.Background())
 			defer cancel()
 			for range app.MaxWatchersPerClient {
-				r.watch(ctx, domain.Root(), app.WatchParams{Client: "198.51.100.1"})
+				r.watch(ctx, domain.Root(), ports.WatchParams{Client: "198.51.100.1"})
 			}
 			synctest.Wait()
 			require.Equal(t, app.MaxWatchersPerClient, r.events.Watchers())
-			err := r.events.Watch(ctx, domain.Root(), app.WatchParams{Client: "198.51.100.1"}, noop)
+			err := r.events.Watch(ctx, domain.Root(), ports.WatchParams{Client: "198.51.100.1"}, noop)
 			assert.ErrorIs(t, err, domain.ErrResourceExhausted)
 			// Another client, and callers in process, are not affected.
-			r.watch(ctx, domain.Root(), app.WatchParams{Client: "198.51.100.2"})
+			r.watch(ctx, domain.Root(), ports.WatchParams{Client: "198.51.100.2"})
-			r.watch(ctx, domain.Root(), app.WatchParams{})
+			r.watch(ctx, domain.Root(), ports.WatchParams{})
 			synctest.Wait()
 			require.Equal(t, app.MaxWatchersPerClient+2, r.events.Watchers())
 			require.Equal(t, 0, r.events.Watchers())
 			again, stop := context.WithCancel(context.Background())
 			stop()
-			assert.NoError(t, r.events.Watch(again, domain.Root(), app.WatchParams{Client: "198.51.100.1"}, noop), "the slots were released")
+			assert.NoError(t, r.events.Watch(again, domain.Root(), ports.WatchParams{Client: "198.51.100.1"}, noop), "the slots were released")
 		})
 	})
 }
 			defer cancel()
 			r := newEventRig(t, 0)
 			l, n := r.liveRepo("secret", domain.VisibilityPrivate, now)
-			root := r.watch(ctx, domain.Root(), app.WatchParams{})
+			root := r.watch(ctx, domain.Root(), ports.WatchParams{})
 			synctest.Wait()
 			require.Equal(t, 1, r.events.Watchers())
 			r.push(n, 1)
 			// An anonymous caller that resumes with an id nobody issued gets what
 			// is buffered, filtered: the public update and the public push, not the
 			// pushes of the private era.
-			anon := r.watch(ctx, domain.Anonymous(), app.WatchParams{ResumeAfter: "bogus"})
+			anon := r.watch(ctx, domain.Anonymous(), ports.WatchParams{ResumeAfter: "bogus"})
 			assert.True(t, anon.next(t).Gap)
 			upd := anon.next(t)
 			require.IsType(t, domain.RepoUpdated{}, upd.Event)
 			r := newEventRig(t, 0)
 			first := now.Add(-time.Hour)
 			l, n := r.liveRepo("again", domain.VisibilityPublic, first)
-			root := r.watch(ctx, domain.Root(), app.WatchParams{})
+			root := r.watch(ctx, domain.Root(), ports.WatchParams{})
 			synctest.Wait()
 			require.Equal(t, 1, r.events.Watchers())
 			r.push(n, 1)
 			r.push(n, 2)
 			root.next(t)
-			anon := r.watch(ctx, domain.Anonymous(), app.WatchParams{ResumeAfter: "bogus"})
+			anon := r.watch(ctx, domain.Anonymous(), ports.WatchParams{ResumeAfter: "bogus"})
 			assert.True(t, anon.next(t).Gap)
 			e := anon.next(t)
 			require.IsType(t, domain.PushEvent{}, e.Event)
 			defer cancel()
 			r := newEventRig(t, 0)
 			l, n := r.liveRepo("hide", domain.VisibilityPublic, now)
-			anon := r.watch(ctx, domain.Anonymous(), app.WatchParams{})
+			anon := r.watch(ctx, domain.Anonymous(), ports.WatchParams{})
-			reader := r.watch(ctx, tokenPrincipal(domain.ScopeRepoRead, "hide"), app.WatchParams{})
+			reader := r.watch(ctx, tokenPrincipal(domain.ScopeRepoRead, "hide"), ports.WatchParams{})
-			other := r.watch(ctx, tokenPrincipal(domain.ScopeRepoRead, "elsewhere"), app.WatchParams{})
+			other := r.watch(ctx, tokenPrincipal(domain.ScopeRepoRead, "elsewhere"), ports.WatchParams{})
-			root := r.watch(ctx, domain.Root(), app.WatchParams{})
+			root := r.watch(ctx, domain.Root(), ports.WatchParams{})
 			synctest.Wait()
 			require.Equal(t, 4, r.events.Watchers())
 			defer cancel()
 			r := newEventRig(t, 0)
 			_, n := r.liveRepo("closed", domain.VisibilityPrivate, now)
-			anon := r.watch(ctx, domain.Anonymous(), app.WatchParams{})
+			anon := r.watch(ctx, domain.Anonymous(), ports.WatchParams{})
 			synctest.Wait()
 			require.Equal(t, 1, r.events.Watchers())
 			r.feed <- domain.RepoUpdated{Repo: n, At: now, Visibility: domain.VisibilityPrivate, Previous: domain.VisibilityPrivate, CreatedAt: now}
 				defer cancel()
 				r := newEventRig(t, 0)
 				l, n := r.liveRepo("secret", domain.VisibilityPrivate, now)
-				anon := r.watch(ctx, domain.Anonymous(), app.WatchParams{})
+				anon := r.watch(ctx, domain.Anonymous(), ports.WatchParams{})
-				root := r.watch(ctx, domain.Root(), app.WatchParams{})
+				root := r.watch(ctx, domain.Root(), ports.WatchParams{})
 				synctest.Wait()
 				require.Equal(t, 2, r.events.Watchers())
 				anon.quiet(t, r, r.repo("open", domain.VisibilityPublic))
-				late := r.watch(ctx, domain.Anonymous(), app.WatchParams{ResumeAfter: "bogus"})
+				late := r.watch(ctx, domain.Anonymous(), ports.WatchParams{ResumeAfter: "bogus"})
 				assert.True(t, late.next(t).Gap)
 				late.quiet(t, r, r.repo("open2", domain.VisibilityPublic))
 			})
 			defer cancel()
 			r := newEventRig(t, 0)
 			n := r.repo("ghost", domain.VisibilityPublic)
-			root := r.watch(ctx, domain.Root(), app.WatchParams{})
+			root := r.watch(ctx, domain.Root(), ports.WatchParams{})
 			synctest.Wait()
 			require.Equal(t, 1, r.events.Watchers())
 			r.feed <- domain.PushEvent{Repo: n, Visibility: domain.VisibilityPublic, At: now}

M internal/app/maintenance.go +2 -0


@@ -38,6 +38,8 @@ type Maintainer struct {
38	wg sync.WaitGroup	38		wg sync.WaitGroup
39	}	39		}
40		40
		41	+	var _ ports.MaintenanceScheduler = (*Maintainer)(nil)
		42	+
41	type maintEntry struct {	43		type maintEntry struct {
42	timer *time.Timer // pending run, nil while running or idle	44		timer *time.Timer // pending run, nil while running or idle
43	running bool	45		running bool

M internal/app/mergerequests.go +29 -102

 	committer domain.Identity
 	bus       ports.EventBus
 	clock     ports.Clock
-	maint     MaintenanceScheduler
+	maint     ports.MaintenanceScheduler
 	mu    sync.Mutex
 	locks map[domain.RepoName]chan struct{}
 }
+var _ ports.MergeRequestService = (*MergeRequests)(nil)
 // MergeRequestsConfig holds what the merge request use cases need. Every field
 // is required.
 type MergeRequestsConfig struct {
 	Bus       ports.EventBus
 	Clock     ports.Clock
 	// Maint queues the maintenance that follows a merge, as it does a push.
-	Maint MaintenanceScheduler
+	Maint ports.MaintenanceScheduler
 }
 // NewMergeRequests builds the merge request use cases.
 	return id, err
 }
-// CreateMergeRequestParams describes the merge request to open.
-type CreateMergeRequestParams struct {
-	Title       string
-	Description string
-	// Source is required; Target defaults to the default branch.
-	Source, Target string
-}
 // Create opens a merge request and publishes MergeRequestOpened. The principal
 // needs mr:write. A request that breaks a rule of ADR 0017 (the texts, a
 // branch that does not exist, source and target the same) is rejected whole
 // with an *domain.InvalidFieldsError naming the fields. An open request with
 // the same source and target gives domain.ErrAlreadyExists.
-func (m *MergeRequests) Create(ctx context.Context, p domain.Principal, name domain.RepoName, params CreateMergeRequestParams) (domain.MergeRequest, error) {
+func (m *MergeRequests) Create(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.CreateMergeRequestParams) (domain.MergeRequest, error) {
 	repo, err := m.writable(ctx, p, name, domain.ScopeMRWrite)
 	if err != nil {
 		return domain.MergeRequest{}, err
 // Only a branch that does not exist is a violation. Any other failure to read
 // Git is returned as an error, so that it is logged and masked, not shown in
 // the field violations.
-func (m *MergeRequests) checkBranches(ctx context.Context, name domain.RepoName, params CreateMergeRequestParams, v *domain.Violations) (source, target string, err error) {
+func (m *MergeRequests) checkBranches(ctx context.Context, name domain.RepoName, params ports.CreateMergeRequestParams, v *domain.Violations) (source, target string, err error) {
 	source, target = params.Source, params.Target
 	if source == "" {
 		v.Add("source_branch", "is required")
 	return source, target, nil
 }
-// ListMergeRequestsParams selects a page of merge requests.
-type ListMergeRequestsParams struct {
-	// State restricts the result; empty means every state.
-	State domain.MRState
-	// PageSize is 0 for the default, and lowered to MaxPageSize.
-	PageSize int
-	// PageToken is the NextPageToken of the previous page, or empty.
-	PageToken string
-}
-// MergeRequestPage is a page of merge requests, highest number first.
-type MergeRequestPage struct {
-	MergeRequests []domain.MergeRequest
-	// NextPageToken is empty on the last page.
-	NextPageToken string
-}
 // List returns a page of the merge requests of a repository, highest number
 // first. The open ones carry the head of their source branch. The page token
 // names the last number of the previous page, so requests created between two
 // pages never shift the others.
-func (m *MergeRequests) List(ctx context.Context, p domain.Principal, name domain.RepoName, params ListMergeRequestsParams) (MergeRequestPage, error) {
+func (m *MergeRequests) List(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.ListMergeRequestsParams) (ports.MergeRequestPage, error) {
 	size, err := pageSize(params.PageSize)
 	if err != nil {
-		return MergeRequestPage{}, err
+		return ports.MergeRequestPage{}, err
 	}
 	after, err := decodeMRToken(params.PageToken)
 	if err != nil {
-		return MergeRequestPage{}, err
+		return ports.MergeRequestPage{}, err
 	}
 	if _, err := m.readable(ctx, p, name); err != nil {
-		return MergeRequestPage{}, err
+		return ports.MergeRequestPage{}, err
 	}
 	all, err := m.store.List(ctx, name)
 	if err != nil {
-		return MergeRequestPage{}, fmt.Errorf("list merge requests of %q: %w", name, err)
+		return ports.MergeRequestPage{}, fmt.Errorf("list merge requests of %q: %w", name, err)
 	}
-	var page MergeRequestPage
+	var page ports.MergeRequestPage
 	page.MergeRequests, page.NextPageToken = pageAfter(all, size,
 		func(mr domain.MergeRequest) bool {
 			return (params.State == "" || mr.State == params.State) && (after == 0 || mr.Number < after)
 		encodeMRToken)
 	for i, mr := range page.MergeRequests {
 		if page.MergeRequests[i], err = m.withHead(ctx, mr); err != nil {
-			return MergeRequestPage{}, err
+			return ports.MergeRequestPage{}, err
 		}
 	}
 	return page, nil
 	return repo, mr, nil
 }
-// MergeRequestDetail is a merge request with its review data.
-type MergeRequestDetail struct {
-	MergeRequest domain.MergeRequest
-	// Commits are the commits of the head that the target lacks, newest
-	// first, at most MaxMergeRequestCommits.
-	Commits          []domain.Commit
-	CommitsTruncated bool
-	// DiffBaseID is the commit the diff compares from; zero when the source
-	// branch is gone, then the diff is empty.
-	DiffBaseID domain.ObjectID
-	Stats      domain.DiffStats
-	Diff       domain.Diff
-	// Comments are the comments, oldest first.
-	Comments []domain.Comment
-	// LastReadID is the head recorded by MarkRead; zero when none.
-	LastReadID domain.ObjectID
-	// LastReadLost tells that since-last-read was asked for, a head was
-	// recorded, but that commit is gone: the diff is against the target.
-	LastReadLost bool
-}
 // Get returns a merge request with its commits, its diff, its comments and the
 // read position. The diff compares the merge base of the target and the head
 // with the head ("target...head"), within domain.DefaultDiffLimits. With
 // still exists; when none was recorded the diff is the default one, and when
 // the recorded commit is gone too, with LastReadLost set. A merged or closed
 // request keeps the head and the base it had.
-func (m *MergeRequests) Get(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, sinceLastRead bool) (MergeRequestDetail, error) {
+func (m *MergeRequests) Get(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, sinceLastRead bool) (ports.MergeRequestDetail, error) {
 	_, mr, err := m.get(ctx, p, name, number)
 	if err != nil {
-		return MergeRequestDetail{}, err
+		return ports.MergeRequestDetail{}, err
 	}
 	if mr, err = m.withHead(ctx, mr); err != nil {
-		return MergeRequestDetail{}, err
+		return ports.MergeRequestDetail{}, err
 	}
-	d := MergeRequestDetail{MergeRequest: mr}
+	d := ports.MergeRequestDetail{MergeRequest: mr}
 	if d.Comments, err = m.store.ListComments(ctx, name, number); err != nil {
-		return MergeRequestDetail{}, fmt.Errorf("list comments of !%d in %q: %w", number, name, err)
+		return ports.MergeRequestDetail{}, fmt.Errorf("list comments of !%d in %q: %w", number, name, err)
 	}
 	if d.LastReadID, err = m.store.GetRead(ctx, name, number); err != nil {
-		return MergeRequestDetail{}, err
+		return ports.MergeRequestDetail{}, err
 	}
 	exclude, base, err := m.rangeOf(ctx, mr)
 	if err != nil {
-		return MergeRequestDetail{}, err
+		return ports.MergeRequestDetail{}, err
 	}
 	head := mr.HeadID
 	if head.IsZero() {
 		// source branch; once it is deleted, gc may prune them.
 		switch ok, err := m.git.HasCommit(ctx, name, head); {
 		case err != nil:
-			return MergeRequestDetail{}, err
+			return ports.MergeRequestDetail{}, err
 		case !ok:
 			return d, nil // the reviewed commits are gone: no commits, no diff
 		}
 	}
 	if d.Commits, d.CommitsTruncated, err = m.git.ListRange(ctx, name, exclude, head, MaxMergeRequestCommits); err != nil {
-		return MergeRequestDetail{}, err
+		return ports.MergeRequestDetail{}, err
 	}
 	if sinceLastRead && !d.LastReadID.IsZero() {
 		switch ok, err := m.git.HasCommit(ctx, name, d.LastReadID); {
 		case err != nil:
-			return MergeRequestDetail{}, err
+			return ports.MergeRequestDetail{}, err
 		case ok:
 			base = d.LastReadID
 		default:
 	}
 	d.DiffBaseID = base
 	if d.Stats, d.Diff, err = m.git.DiffCommits(ctx, name, base, head, domain.DefaultDiffLimits()); err != nil {
-		return MergeRequestDetail{}, err
+		return ports.MergeRequestDetail{}, err
 	}
 	return d, nil
 }
 	return tip, base, err
 }
-// AddCommentParams describes the comment to add.
-type AddCommentParams struct {
-	// Path, Line and Side designate a line of the diff; all empty for a
-	// general comment.
-	Path string
-	Line int
-	Side domain.DiffSide
-	Text string
-}
 // AddComment adds a comment and publishes CommentAdded. The principal needs
 // mr:write. The text must follow the rules of ADR 0017 and not be blank; a
 // comment on a line must name a line of the current diff of the request (see
 // domain.Diff.HasLine), else the call fails with domain.ErrInvalid. A request
 // that is not open gives domain.ErrPreconditionFailed, and one that already
 // holds MaxCommentsPerMergeRequest comments domain.ErrResourceExhausted.
-func (m *MergeRequests) AddComment(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params AddCommentParams) (domain.Comment, error) {
+func (m *MergeRequests) AddComment(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.AddCommentParams) (domain.Comment, error) {
 	repo, err := m.writable(ctx, p, name, domain.ScopeMRWrite)
 	if err != nil {
 		return domain.Comment{}, err
 // checkLine verifies that a comment designates a line of the current diff of
 // the request.
-func (m *MergeRequests) checkLine(ctx context.Context, mr domain.MergeRequest, params AddCommentParams) error {
+func (m *MergeRequests) checkLine(ctx context.Context, mr domain.MergeRequest, params ports.AddCommentParams) error {
 	var v domain.Violations
 	_, base, err := m.rangeOf(ctx, mr)
 	if err != nil {
 	return head, nil
 }
-// MergeParams describes the merge to perform.
-type MergeParams struct {
-	// Mode defaults to fast-forward.
-	Mode domain.MergeMode
-	// HeadID is the commit the caller reviewed; the source branch must still
-	// point to it.
-	HeadID domain.ObjectID
-	// DeleteSource deletes the source branch after the merge.
-	DeleteSource bool
-}
-// MergeResult is a merged request and what happened to its source branch.
-type MergeResult struct {
-	domain.MergeRequest
-	// SourceDeleted is true when DeleteSource was asked and the branch is
-	// gone.
-	SourceDeleted bool
-}
 // Merge merges an open merge request, publishes MergeRequestMerged then a
 // PushEvent for the target branch, and returns the merged request. The
 // principal needs mr:merge. Merges of one repository run one at a time.
 // request. After the merge the source is deleted if it still points to the
 // head; the PushEvent then carries the deletion too. A failed deletion is
 // logged and leaves the branch: the merge stands and SourceDeleted is false.
-func (m *MergeRequests) Merge(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params MergeParams) (MergeResult, error) {
+func (m *MergeRequests) Merge(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.MergeParams) (ports.MergeResult, error) {
 	mr, deleted, err := m.merge(ctx, p, name, number, params)
-	return MergeResult{MergeRequest: mr, SourceDeleted: deleted}, err
+	return ports.MergeResult{MergeRequest: mr, SourceDeleted: deleted}, err
 }
-func (m *MergeRequests) merge(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params MergeParams) (domain.MergeRequest, bool, error) {
+func (m *MergeRequests) merge(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.MergeParams) (domain.MergeRequest, bool, error) {
 	repo, err := m.writable(ctx, p, name, domain.ScopeMRMerge)
 	if err != nil {
 		return domain.MergeRequest{}, false, err

M internal/app/mergerequests_delete_test.go +13 -12

 	"bnema.dev/ermite/internal/adapters/gitcli"
 	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // A merge can delete its source branch; the push event carries both refs.
 			mr := r.open("feat")
 			r.drain()
-			res, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{Mode: mode, HeadID: head, DeleteSource: true})
+			res, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{Mode: mode, HeadID: head, DeleteSource: true})
 			require.NoError(t, err)
 			assert.True(t, res.SourceDeleted)
 			assert.Equal(t, domain.MRStateMerged, res.State)
 		r.seed()
 		head := r.feature("feat")
 		mr := r.open("feat")
-		res, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head})
+		res, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head})
 		require.NoError(t, err)
 		assert.False(t, res.SourceDeleted)
 		assert.Equal(t, head, r.branchHead("feat"))
 		r.sh("checkout", "-q", "-B", "release", "main")
 		r.push("release")
 		mr := r.open("feat")
-		_, err := r.mrs.Create(r.ctx, root, r.repo, app.CreateMergeRequestParams{Title: "to release", Source: "feat", Target: "release"})
+		_, err := r.mrs.Create(r.ctx, root, r.repo, ports.CreateMergeRequestParams{Title: "to release", Source: "feat", Target: "release"})
 		require.NoError(t, err)
-		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head, DeleteSource: true})
+		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head, DeleteSource: true})
 		require.ErrorIs(t, err, domain.ErrPreconditionFailed)
 		assert.Contains(t, err.Error(), "!2 still uses")
 		assert.Equal(t, main, r.branchHead("main"), "not merged")
 		r.sh("checkout", "-q", "-B", "sub", "feat")
 		r.commit(author, "d.txt", "dee\n", "add d")
 		r.push("sub")
-		_, err := r.mrs.Create(r.ctx, root, r.repo, app.CreateMergeRequestParams{Title: "stacked", Source: "sub", Target: "feat"})
+		_, err := r.mrs.Create(r.ctx, root, r.repo, ports.CreateMergeRequestParams{Title: "stacked", Source: "sub", Target: "feat"})
 		require.NoError(t, err)
-		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head, DeleteSource: true})
+		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head, DeleteSource: true})
 		require.ErrorIs(t, err, domain.ErrPreconditionFailed)
 		assert.Equal(t, head, r.branchHead("feat"))
 	})
 		r.sh("checkout", "-q", "-B", "old", "main~1")
 		r.push("old")
 		old := r.branchHead("old")
-		mr, err := r.mrs.Create(r.ctx, root, r.repo, app.CreateMergeRequestParams{Title: "back", Source: "main", Target: "old"})
+		mr, err := r.mrs.Create(r.ctx, root, r.repo, ports.CreateMergeRequestParams{Title: "back", Source: "main", Target: "old"})
 		require.NoError(t, err)
-		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: main, DeleteSource: true})
+		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: main, DeleteSource: true})
 		require.ErrorIs(t, err, domain.ErrPreconditionFailed)
 		assert.Contains(t, err.Error(), "default branch")
 		assert.Equal(t, old, r.branchHead("old"), "not merged")
 	r.seed()
 	head := r.feature("feat")
 	mr := r.open("feat")
-	res, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{Mode: domain.MergeModeSquash, HeadID: head, DeleteSource: true})
+	res, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{Mode: domain.MergeModeSquash, HeadID: head, DeleteSource: true})
 	require.NoError(t, err)
 	require.True(t, res.SourceDeleted)
 	r.seed()
 	head := r.feature("feat")
 	mr := r.open("feat")
-	_, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head, DeleteSource: true})
+	_, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head, DeleteSource: true})
 	require.NoError(t, err)
-	_, err = r.mrs.Create(r.ctx, root, r.repo, app.CreateMergeRequestParams{Title: "late", Source: "feat"})
+	_, err = r.mrs.Create(r.ctx, root, r.repo, ports.CreateMergeRequestParams{Title: "late", Source: "feat"})
 	require.ErrorIs(t, err, domain.ErrInvalid)
 	assert.Contains(t, fieldsOf(t, err), "source_branch")
 }
 	})
 	r.drain()
-	res, err := mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head, DeleteSource: true})
+	res, err := mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head, DeleteSource: true})
 	require.NoError(t, err, "the merge stands")
 	assert.False(t, res.SourceDeleted)
 	assert.Equal(t, domain.MRStateMerged, res.State)

M internal/app/mergerequests_integration_test.go +116 -115

 	"bnema.dev/ermite/internal/adapters/kvstore"
 	"bnema.dev/ermite/internal/adapters/sshsig"
 	"bnema.dev/ermite/internal/app"
-	appmocks "bnema.dev/ermite/internal/app/mocks"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
+	"bnema.dev/ermite/internal/ports/mocks"
 )
 // queuedRepos records the repositories whose maintenance was queued.
 	store  *kvstore.Store
 	git    *gitcli.Git
 	bus    *eventbus.Bus
-	sched  *appmocks.MaintenanceScheduler
+	sched  *mocks.MaintenanceScheduler
 	queued *queuedRepos
 	events <-chan domain.Event
 	work   string
 	require.NoError(t, err)
 	bus := eventbus.NewWithBuffer(1024)
 	committer := domain.Identity{Name: "ermite", Email: "ermite@git.example.org"}
-	sched := appmocks.NewMaintenanceScheduler(t)
+	sched := mocks.NewMaintenanceScheduler(t)
 	queued := &queuedRepos{}
 	sched.EXPECT().Schedule(mock.Anything, mock.Anything).Run(queued.add).Return().Maybe()
 	r := &mrRig{
 		Meta: store, Store: store.MergeRequests(), Repos: git, Git: git, Signer: signer,
 		Committer: committer, Bus: bus, Clock: fixedClock{}, Maint: r.sched,
 	})
-	_, err = r.repos.Create(ctx, root, app.CreateParams{Name: r.repo, Visibility: domain.VisibilityPrivate})
+	_, err = r.repos.Create(ctx, root, ports.CreateRepoParams{Name: r.repo, Visibility: domain.VisibilityPrivate})
 	require.NoError(t, err)
 	r.sh("init", "-q", "--initial-branch=main")
 	return r
 func (r *mrRig) open(branch string) domain.MergeRequest {
 	r.t.Helper()
-	mr, err := r.mrs.Create(r.ctx, root, r.repo, app.CreateMergeRequestParams{Title: "Add " + branch, Source: branch})
+	mr, err := r.mrs.Create(r.ctx, root, r.repo, ports.CreateMergeRequestParams{Title: "Add " + branch, Source: branch})
 	require.NoError(r.t, err)
 	return mr
 }
 	tests := []struct {
 		name   string
-		params app.CreateMergeRequestParams
+		params ports.CreateMergeRequestParams
 		field  string // "" for valid
 	}{
-		{"valid, default target", app.CreateMergeRequestParams{Title: "t", Source: "feat"}, ""},
+		{"valid, default target", ports.CreateMergeRequestParams{Title: "t", Source: "feat"}, ""},
-		{"valid, explicit target and description", app.CreateMergeRequestParams{Title: "t", Description: "a\nb", Source: "other", Target: "main"}, ""},
+		{"valid, explicit target and description", ports.CreateMergeRequestParams{Title: "t", Description: "a\nb", Source: "other", Target: "main"}, ""},
-		{"empty title", app.CreateMergeRequestParams{Title: "", Source: "feat", Target: "other"}, "title"},
+		{"empty title", ports.CreateMergeRequestParams{Title: "", Source: "feat", Target: "other"}, "title"},
-		{"two-line title", app.CreateMergeRequestParams{Title: "a\nb", Source: "feat", Target: "other"}, "title"},
+		{"two-line title", ports.CreateMergeRequestParams{Title: "a\nb", Source: "feat", Target: "other"}, "title"},
-		{"title too long", app.CreateMergeRequestParams{Title: strings.Repeat("x", 121), Source: "feat", Target: "other"}, "title"},
+		{"title too long", ports.CreateMergeRequestParams{Title: strings.Repeat("x", 121), Source: "feat", Target: "other"}, "title"},
-		{"title with a bidi override", app.CreateMergeRequestParams{Title: "a\u202eb", Source: "feat", Target: "other"}, "title"},
+		{"title with a bidi override", ports.CreateMergeRequestParams{Title: "a\u202eb", Source: "feat", Target: "other"}, "title"},
-		{"title with an escape", app.CreateMergeRequestParams{Title: "\x1b[31m", Source: "feat", Target: "other"}, "title"},
+		{"title with an escape", ports.CreateMergeRequestParams{Title: "\x1b[31m", Source: "feat", Target: "other"}, "title"},
-		{"description with a control character", app.CreateMergeRequestParams{Title: "t", Description: "a\x07", Source: "feat", Target: "other"}, "description"},
+		{"description with a control character", ports.CreateMergeRequestParams{Title: "t", Description: "a\x07", Source: "feat", Target: "other"}, "description"},
-		{"description with a bidi isolate", app.CreateMergeRequestParams{Title: "t", Description: "a\u2066b", Source: "feat", Target: "other"}, "description"},
+		{"description with a bidi isolate", ports.CreateMergeRequestParams{Title: "t", Description: "a\u2066b", Source: "feat", Target: "other"}, "description"},
-		{"description too long", app.CreateMergeRequestParams{Title: "t", Description: strings.Repeat("x", 8001), Source: "feat", Target: "other"}, "description"},
+		{"description too long", ports.CreateMergeRequestParams{Title: "t", Description: strings.Repeat("x", 8001), Source: "feat", Target: "other"}, "description"},
-		{"description not utf-8", app.CreateMergeRequestParams{Title: "t", Description: "\xff", Source: "feat", Target: "other"}, "description"},
+		{"description not utf-8", ports.CreateMergeRequestParams{Title: "t", Description: "\xff", Source: "feat", Target: "other"}, "description"},
-		{"source missing", app.CreateMergeRequestParams{Title: "t", Source: ""}, "source_branch"},
+		{"source missing", ports.CreateMergeRequestParams{Title: "t", Source: ""}, "source_branch"},
-		{"source does not exist", app.CreateMergeRequestParams{Title: "t", Source: "nope", Target: "main"}, "source_branch"},
+		{"source does not exist", ports.CreateMergeRequestParams{Title: "t", Source: "nope", Target: "main"}, "source_branch"},
-		{"source is not a branch name", app.CreateMergeRequestParams{Title: "t", Source: "a..b", Target: "main"}, "source_branch"},
+		{"source is not a branch name", ports.CreateMergeRequestParams{Title: "t", Source: "a..b", Target: "main"}, "source_branch"},
-		{"source is a full ref", app.CreateMergeRequestParams{Title: "t", Source: "refs/heads/feat", Target: "main"}, "source_branch"},
+		{"source is a full ref", ports.CreateMergeRequestParams{Title: "t", Source: "refs/heads/feat", Target: "main"}, "source_branch"},
-		{"target does not exist", app.CreateMergeRequestParams{Title: "t", Source: "feat", Target: "nope"}, "target_branch"},
+		{"target does not exist", ports.CreateMergeRequestParams{Title: "t", Source: "feat", Target: "nope"}, "target_branch"},
-		{"same branch", app.CreateMergeRequestParams{Title: "t", Source: "feat", Target: "feat"}, "target_branch"},
+		{"same branch", ports.CreateMergeRequestParams{Title: "t", Source: "feat", Target: "feat"}, "target_branch"},
 	}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 	}
 	t.Run("a request is rejected whole with every field named", func(t *testing.T) {
-		_, err := r.mrs.Create(r.ctx, root, r.repo, app.CreateMergeRequestParams{Title: "a\nb", Description: "\x07", Source: "nope", Target: "feat"})
+		_, err := r.mrs.Create(r.ctx, root, r.repo, ports.CreateMergeRequestParams{Title: "a\nb", Description: "\x07", Source: "nope", Target: "feat"})
 		got := fieldsOf(t, err)
 		assert.Contains(t, got, "title")
 		assert.Contains(t, got, "description")
 	second := r.open("two")
 	assert.Equal(t, int64(2), second.Number)
-	_, err := r.mrs.Create(r.ctx, root, r.repo, app.CreateMergeRequestParams{Title: "again", Source: "one", Target: "main"})
+	_, err := r.mrs.Create(r.ctx, root, r.repo, ports.CreateMergeRequestParams{Title: "again", Source: "one", Target: "main"})
 	require.ErrorIs(t, err, domain.ErrAlreadyExists, "same open source and target")
-	_, err = r.mrs.Create(r.ctx, root, r.repo, app.CreateMergeRequestParams{Title: "again", Source: "one"})
+	_, err = r.mrs.Create(r.ctx, root, r.repo, ports.CreateMergeRequestParams{Title: "again", Source: "one"})
 	require.ErrorIs(t, err, domain.ErrAlreadyExists, "the default target is the same target")
 	// Another target is another request.
 	r.sh("checkout", "-q", "-B", "stage", "main")
 	r.push("stage")
-	third, err := r.mrs.Create(r.ctx, root, r.repo, app.CreateMergeRequestParams{Title: "to stage", Source: "one", Target: "stage"})
+	third, err := r.mrs.Create(r.ctx, root, r.repo, ports.CreateMergeRequestParams{Title: "to stage", Source: "one", Target: "stage"})
 	require.NoError(t, err)
 	assert.Equal(t, int64(3), third.Number)
 	// Once the first is closed, the pair is free again, with a new number.
 	_, err = r.mrs.Close(r.ctx, root, r.repo, first.Number)
 	require.NoError(t, err)
-	fourth, err := r.mrs.Create(r.ctx, root, r.repo, app.CreateMergeRequestParams{Title: "retry", Source: "one"})
+	fourth, err := r.mrs.Create(r.ctx, root, r.repo, ports.CreateMergeRequestParams{Title: "retry", Source: "one"})
 	require.NoError(t, err)
 	assert.Equal(t, int64(4), fourth.Number, "numbers are never reused")
 }
 	reads := map[string]func(p domain.Principal) error{
 		"List": func(p domain.Principal) error {
-			_, err := r.mrs.List(r.ctx, p, r.repo, app.ListMergeRequestsParams{})
+			_, err := r.mrs.List(r.ctx, p, r.repo, ports.ListMergeRequestsParams{})
 			return err
 		},
 		"Get": func(p domain.Principal) error {
 	}
 	_, err := r.mrs.Get(r.ctx, reader, r.repo, n+1, false)
 	assert.ErrorIs(t, err, domain.ErrNotFound, "unknown number")
-	_, err = r.mrs.List(r.ctx, root, name(t, "ghost"), app.ListMergeRequestsParams{})
+	_, err = r.mrs.List(r.ctx, root, name(t, "ghost"), ports.ListMergeRequestsParams{})
 	assert.ErrorIs(t, err, domain.ErrNotFound, "unknown repository")
 	writes := map[string]func(p domain.Principal) error{
 		"Create": func(p domain.Principal) error {
-			_, err := r.mrs.Create(r.ctx, p, r.repo, app.CreateMergeRequestParams{Title: "t", Source: "feat", Target: "feat"})
+			_, err := r.mrs.Create(r.ctx, p, r.repo, ports.CreateMergeRequestParams{Title: "t", Source: "feat", Target: "feat"})
 			return err
 		},
 		"AddComment": func(p domain.Principal) error {
-			_, err := r.mrs.AddComment(r.ctx, p, r.repo, n, app.AddCommentParams{Text: "x"})
+			_, err := r.mrs.AddComment(r.ctx, p, r.repo, n, ports.AddCommentParams{Text: "x"})
 			return err
 		},
 		"ResolveComment": func(p domain.Principal) error {
 			return err
 		},
 		"Merge": func(p domain.Principal) error {
-			_, err := r.mrs.Merge(r.ctx, p, r.repo, n+100, app.MergeParams{HeadID: mr.HeadID})
+			_, err := r.mrs.Merge(r.ctx, p, r.repo, n+100, ports.MergeParams{HeadID: mr.HeadID})
 			return err
 		},
 	}
 	// On a public repository an anonymous caller reads, but writing is
 	// unauthenticated rather than not found.
 	pubName := name(t, "pub")
-	_, err = r.repos.Create(r.ctx, root, app.CreateParams{Name: pubName, Visibility: domain.VisibilityPublic})
+	_, err = r.repos.Create(r.ctx, root, ports.CreateRepoParams{Name: pubName, Visibility: domain.VisibilityPublic})
 	require.NoError(t, err)
-	_, err = r.mrs.List(r.ctx, domain.Anonymous(), pubName, app.ListMergeRequestsParams{})
+	_, err = r.mrs.List(r.ctx, domain.Anonymous(), pubName, ports.ListMergeRequestsParams{})
 	assert.NoError(t, err)
-	_, err = r.mrs.Create(r.ctx, domain.Anonymous(), pubName, app.CreateMergeRequestParams{Title: "t", Source: "a", Target: "b"})
+	_, err = r.mrs.Create(r.ctx, domain.Anonymous(), pubName, ports.CreateMergeRequestParams{Title: "t", Source: "a", Target: "b"})
 	assert.ErrorIs(t, err, domain.ErrUnauthenticated)
 }
 	require.NoError(t, err)
 	r.sh("checkout", "-q", "main")
 	merged := r.feature("f0")
-	_, err = r.mrs.Merge(r.ctx, root, r.repo, 1, app.MergeParams{HeadID: merged})
+	_, err = r.mrs.Merge(r.ctx, root, r.repo, 1, ports.MergeParams{HeadID: merged})
 	require.NoError(t, err)
 	r.sh("branch", "-D", "f4")
 	r.run(r.bare(), r.env(author), "branch", "-D", "f4")
-	numbers := func(p app.MergeRequestPage) []int64 {
+	numbers := func(p ports.MergeRequestPage) []int64 {
 		var out []int64
 		for _, m := range p.MergeRequests {
 			out = append(out, m.Number)
 		}
 		return out
 	}
-	all, err := r.mrs.List(r.ctx, root, r.repo, app.ListMergeRequestsParams{})
+	all, err := r.mrs.List(r.ctx, root, r.repo, ports.ListMergeRequestsParams{})
 	require.NoError(t, err)
 	assert.Equal(t, []int64{5, 4, 3, 2, 1}, numbers(all), "highest number first")
 	assert.Empty(t, all.NextPageToken)
-	open, err := r.mrs.List(r.ctx, root, r.repo, app.ListMergeRequestsParams{State: domain.MRStateOpen})
+	open, err := r.mrs.List(r.ctx, root, r.repo, ports.ListMergeRequestsParams{State: domain.MRStateOpen})
 	require.NoError(t, err)
 	assert.Equal(t, []int64{5, 4, 3}, numbers(open))
 	for _, m := range open.MergeRequests {
 			assert.False(t, m.HeadID.IsZero(), "an open request carries its head")
 		}
 	}
-	closed, err := r.mrs.List(r.ctx, root, r.repo, app.ListMergeRequestsParams{State: domain.MRStateClosed})
+	closed, err := r.mrs.List(r.ctx, root, r.repo, ports.ListMergeRequestsParams{State: domain.MRStateClosed})
 	require.NoError(t, err)
 	assert.Equal(t, []int64{2}, numbers(closed))
-	mergedPage, err := r.mrs.List(r.ctx, root, r.repo, app.ListMergeRequestsParams{State: domain.MRStateMerged})
+	mergedPage, err := r.mrs.List(r.ctx, root, r.repo, ports.ListMergeRequestsParams{State: domain.MRStateMerged})
 	require.NoError(t, err)
 	assert.Equal(t, []int64{1}, numbers(mergedPage))
 	assert.Equal(t, merged, mergedPage.MergeRequests[0].HeadID, "a merged request keeps the head it had")
 	// Paging: the token names the last number.
-	p1, err := r.mrs.List(r.ctx, root, r.repo, app.ListMergeRequestsParams{PageSize: 2})
+	p1, err := r.mrs.List(r.ctx, root, r.repo, ports.ListMergeRequestsParams{PageSize: 2})
 	require.NoError(t, err)
 	assert.Equal(t, []int64{5, 4}, numbers(p1))
 	require.NotEmpty(t, p1.NextPageToken)
 	// A request created between the pages does not shift them.
 	r.feature("late")
 	r.open("late")
-	p2, err := r.mrs.List(r.ctx, root, r.repo, app.ListMergeRequestsParams{PageSize: 2, PageToken: p1.NextPageToken})
+	p2, err := r.mrs.List(r.ctx, root, r.repo, ports.ListMergeRequestsParams{PageSize: 2, PageToken: p1.NextPageToken})
 	require.NoError(t, err)
 	assert.Equal(t, []int64{3, 2}, numbers(p2))
-	p3, err := r.mrs.List(r.ctx, root, r.repo, app.ListMergeRequestsParams{PageSize: 2, PageToken: p2.NextPageToken})
+	p3, err := r.mrs.List(r.ctx, root, r.repo, ports.ListMergeRequestsParams{PageSize: 2, PageToken: p2.NextPageToken})
 	require.NoError(t, err)
 	assert.Equal(t, []int64{1}, numbers(p3))
 	assert.Empty(t, p3.NextPageToken)
 	for _, tok := range []string{"garbage", "bW9yZQ"} {
-		_, err = r.mrs.List(r.ctx, root, r.repo, app.ListMergeRequestsParams{PageToken: tok})
+		_, err = r.mrs.List(r.ctx, root, r.repo, ports.ListMergeRequestsParams{PageToken: tok})
 		assert.ErrorIs(t, err, domain.ErrInvalidPageToken)
 	}
-	_, err = r.mrs.List(r.ctx, root, r.repo, app.ListMergeRequestsParams{PageSize: -1})
+	_, err = r.mrs.List(r.ctx, root, r.repo, ports.ListMergeRequestsParams{PageSize: -1})
 	assert.ErrorIs(t, err, domain.ErrInvalidPageSize)
 	_ = nums
 }
 	main := r.seed()
 	head := r.feature("feat")
 	mr := r.open("feat")
-	_, err := r.mrs.AddComment(r.ctx, root, r.repo, mr.Number, app.AddCommentParams{Text: "first"})
+	_, err := r.mrs.AddComment(r.ctx, root, r.repo, mr.Number, ports.AddCommentParams{Text: "first"})
 	require.NoError(t, err)
-	_, err = r.mrs.AddComment(r.ctx, root, r.repo, mr.Number, app.AddCommentParams{Text: "second"})
+	_, err = r.mrs.AddComment(r.ctx, root, r.repo, mr.Number, ports.AddCommentParams{Text: "second"})
 	require.NoError(t, err)
 	d, err := r.mrs.Get(r.ctx, reader, r.repo, mr.Number, false)
 	tests := []struct {
 		name   string
-		params app.AddCommentParams
+		params ports.AddCommentParams
 		field  string // "" for valid
 	}{
-		{"general", app.AddCommentParams{Text: "looks good"}, ""},
+		{"general", ports.AddCommentParams{Text: "looks good"}, ""},
-		{"multi-line general", app.AddCommentParams{Text: "a\n\nb"}, ""},
+		{"multi-line general", ports.AddCommentParams{Text: "a\n\nb"}, ""},
-		{"new side of a changed line", app.AddCommentParams{Path: "a.txt", Line: 2, Side: domain.SideNew, Text: "x"}, ""},
+		{"new side of a changed line", ports.AddCommentParams{Path: "a.txt", Line: 2, Side: domain.SideNew, Text: "x"}, ""},
-		{"old side of a changed line", app.AddCommentParams{Path: "a.txt", Line: 2, Side: domain.SideOld, Text: "x"}, ""},
+		{"old side of a changed line", ports.AddCommentParams{Path: "a.txt", Line: 2, Side: domain.SideOld, Text: "x"}, ""},
-		{"context line", app.AddCommentParams{Path: "a.txt", Line: 3, Side: domain.SideNew, Text: "x"}, ""},
+		{"context line", ports.AddCommentParams{Path: "a.txt", Line: 3, Side: domain.SideNew, Text: "x"}, ""},
-		{"added file", app.AddCommentParams{Path: "c.txt", Line: 1, Side: domain.SideNew, Text: "x"}, ""},
+		{"added file", ports.AddCommentParams{Path: "c.txt", Line: 1, Side: domain.SideNew, Text: "x"}, ""},
-		{"empty text", app.AddCommentParams{Text: ""}, "text"},
+		{"empty text", ports.AddCommentParams{Text: ""}, "text"},
-		{"blank text", app.AddCommentParams{Text: " \n "}, "text"},
+		{"blank text", ports.AddCommentParams{Text: " \n "}, "text"},
-		{"text too long", app.AddCommentParams{Text: strings.Repeat("x", 8001)}, "text"},
+		{"text too long", ports.AddCommentParams{Text: strings.Repeat("x", 8001)}, "text"},
-		{"text with a control character", app.AddCommentParams{Text: "a\x1b[0m"}, "text"},
+		{"text with a control character", ports.AddCommentParams{Text: "a\x1b[0m"}, "text"},
-		{"text with a tab", app.AddCommentParams{Text: "a\tb"}, "text"},
+		{"text with a tab", ports.AddCommentParams{Text: "a\tb"}, "text"},
-		{"text with a bidi override", app.AddCommentParams{Text: "a\u202eb"}, "text"},
+		{"text with a bidi override", ports.AddCommentParams{Text: "a\u202eb"}, "text"},
-		{"line outside the diff", app.AddCommentParams{Path: "a.txt", Line: 40, Side: domain.SideNew, Text: "x"}, "path"},
+		{"line outside the diff", ports.AddCommentParams{Path: "a.txt", Line: 40, Side: domain.SideNew, Text: "x"}, "path"},
-		{"unchanged file", app.AddCommentParams{Path: "b.txt", Line: 1, Side: domain.SideNew, Text: "x"}, "path"},
+		{"unchanged file", ports.AddCommentParams{Path: "b.txt", Line: 1, Side: domain.SideNew, Text: "x"}, "path"},
-		{"unknown path", app.AddCommentParams{Path: "nope.txt", Line: 1, Side: domain.SideNew, Text: "x"}, "path"},
+		{"unknown path", ports.AddCommentParams{Path: "nope.txt", Line: 1, Side: domain.SideNew, Text: "x"}, "path"},
-		{"deleted line on the wrong side", app.AddCommentParams{Path: "c.txt", Line: 1, Side: domain.SideOld, Text: "x"}, "path"},
+		{"deleted line on the wrong side", ports.AddCommentParams{Path: "c.txt", Line: 1, Side: domain.SideOld, Text: "x"}, "path"},
-		{"path without a line", app.AddCommentParams{Path: "a.txt", Side: domain.SideNew, Text: "x"}, "line"},
+		{"path without a line", ports.AddCommentParams{Path: "a.txt", Side: domain.SideNew, Text: "x"}, "line"},
-		{"path without a side", app.AddCommentParams{Path: "a.txt", Line: 2, Text: "x"}, "side"},
+		{"path without a side", ports.AddCommentParams{Path: "a.txt", Line: 2, Text: "x"}, "side"},
-		{"line without a path", app.AddCommentParams{Line: 2, Side: domain.SideNew, Text: "x"}, "path"},
+		{"line without a path", ports.AddCommentParams{Line: 2, Side: domain.SideNew, Text: "x"}, "path"},
-		{"side without a path", app.AddCommentParams{Side: domain.SideOld, Text: "x"}, "path"},
+		{"side without a path", ports.AddCommentParams{Side: domain.SideOld, Text: "x"}, "path"},
-		{"negative line", app.AddCommentParams{Path: "a.txt", Line: -2, Side: domain.SideNew, Text: "x"}, "line"},
+		{"negative line", ports.AddCommentParams{Path: "a.txt", Line: -2, Side: domain.SideNew, Text: "x"}, "line"},
 	}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {
 	t.Run("not open", func(t *testing.T) {
 		_, err := r.mrs.Close(r.ctx, mrW, r.repo, n)
 		require.NoError(t, err)
-		_, err = r.mrs.AddComment(r.ctx, mrW, r.repo, n, app.AddCommentParams{Text: "late"})
+		_, err = r.mrs.AddComment(r.ctx, mrW, r.repo, n, ports.AddCommentParams{Text: "late"})
 		assert.ErrorIs(t, err, domain.ErrPreconditionFailed)
 		_, err = r.mrs.ResolveComment(r.ctx, mrW, r.repo, n, 1, true)
 		assert.ErrorIs(t, err, domain.ErrPreconditionFailed)
 	ids := make(chan int64, workers)
 	for i := range workers {
 		wg.Go(func() {
-			c, err := r.mrs.AddComment(r.ctx, mrW, r.repo, mr.Number, app.AddCommentParams{Text: fmt.Sprintf("c%d", i)})
+			c, err := r.mrs.AddComment(r.ctx, mrW, r.repo, mr.Number, ports.AddCommentParams{Text: fmt.Sprintf("c%d", i)})
 			if assert.NoError(t, err) {
 				ids <- c.ID
 			}
 	r.seed()
 	r.feature("feat")
 	mr := r.open("feat")
-	c, err := r.mrs.AddComment(r.ctx, mrW, r.repo, mr.Number, app.AddCommentParams{Text: "fix this"})
+	c, err := r.mrs.AddComment(r.ctx, mrW, r.repo, mr.Number, ports.AddCommentParams{Text: "fix this"})
 	require.NoError(t, err)
 	r.drain()
 	r.drain()
 	mr := r.open("feat")
-	c, err := r.mrs.AddComment(r.ctx, mrW, r.repo, mr.Number, app.AddCommentParams{Text: "note"})
+	c, err := r.mrs.AddComment(r.ctx, mrW, r.repo, mr.Number, ports.AddCommentParams{Text: "note"})
 	require.NoError(t, err)
-	_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head})
+	_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head})
 	require.NoError(t, err)
 	r.feature("other")
 	// Failed calls publish nothing.
 	_, err = r.mrs.Close(r.ctx, mrW, r.repo, other.Number)
 	require.Error(t, err)
-	_, err = r.mrs.AddComment(r.ctx, mrW, r.repo, other.Number, app.AddCommentParams{Text: "x"})
+	_, err = r.mrs.AddComment(r.ctx, mrW, r.repo, other.Number, ports.AddCommentParams{Text: "x"})
 	require.Error(t, err)
 	assert.Empty(t, r.drain())
 }
 	mr := r.open("feat")
 	r.drain()
-	merged, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head})
+	merged, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head})
 	require.NoError(t, err)
 	assert.Equal(t, domain.MRStateMerged, merged.State)
 	assert.Equal(t, domain.MergeModeFastForward, merged.MergeMode, "the default mode")
 	assert.Len(t, d.Diff.Files, 2)
 	// Repeating it, or touching a final request, is a failed precondition.
-	_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head})
+	_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head})
 	assert.ErrorIs(t, err, domain.ErrPreconditionFailed)
 	_, err = r.mrs.Close(r.ctx, mrW, r.repo, mr.Number)
 	assert.ErrorIs(t, err, domain.ErrPreconditionFailed)
-	_, err = r.mrs.AddComment(r.ctx, mrW, r.repo, mr.Number, app.AddCommentParams{Text: "x"})
+	_, err = r.mrs.AddComment(r.ctx, mrW, r.repo, mr.Number, ports.AddCommentParams{Text: "x"})
 	assert.ErrorIs(t, err, domain.ErrPreconditionFailed)
 }
 		mr := r.open("feat")
 		r.commit(author, "more.txt", "m\n", "pushed after the review")
 		r.push("feat")
-		_, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head})
+		_, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head})
 		require.ErrorIs(t, err, domain.ErrPreconditionFailed)
 		assert.Contains(t, err.Error(), "branch moved, read again")
 		assert.NotEqual(t, head, r.branchHead("main"), "main did not move")
 		// Reading again gives the new head, which merges.
 		d, err := r.mrs.Get(r.ctx, mrM, r.repo, mr.Number, false)
 		require.NoError(t, err)
-		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: d.MergeRequest.HeadID})
+		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: d.MergeRequest.HeadID})
 		require.NoError(t, err)
 	})
 		tip := r.branchHead("main")
 		for _, mode := range []domain.MergeMode{domain.MergeModeFastForward, domain.MergeModeSquash} {
-			_, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head, Mode: mode})
+			_, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head, Mode: mode})
 			require.ErrorIs(t, err, domain.ErrPreconditionFailed, mode)
 			assert.Contains(t, err.Error(), "rebase", mode)
 		}
 		r.sh("checkout", "-q", "feat")
 		r.sh("rebase", "-q", "main")
 		r.push("feat")
-		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: r.head()})
+		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: r.head()})
 		require.NoError(t, err)
 	})
 		head := r.feature("feat")
 		mr := r.open("feat")
 		modes := []domain.MergeMode{domain.MergeModeFastForward}
-		_, err := r.repos.Update(r.ctx, root, r.repo, app.UpdateParams{AllowedMergeModes: &modes})
+		_, err := r.repos.Update(r.ctx, root, r.repo, ports.UpdateRepoParams{AllowedMergeModes: &modes})
 		require.NoError(t, err)
-		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head, Mode: domain.MergeModeSquash})
+		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head, Mode: domain.MergeModeSquash})
 		require.ErrorIs(t, err, domain.ErrPreconditionFailed)
 		assert.Contains(t, err.Error(), "squash")
-		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head})
+		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head})
 		require.NoError(t, err, "fast-forward is allowed")
 	})
 		head := r.feature("feat")
 		mr := r.open("feat")
 		modes := []domain.MergeMode{domain.MergeModeSquash}
-		_, err := r.repos.Update(r.ctx, root, r.repo, app.UpdateParams{AllowedMergeModes: &modes})
+		_, err := r.repos.Update(r.ctx, root, r.repo, ports.UpdateRepoParams{AllowedMergeModes: &modes})
 		require.NoError(t, err)
-		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head})
+		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head})
 		require.ErrorIs(t, err, domain.ErrPreconditionFailed)
-		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head, Mode: domain.MergeModeSquash})
+		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head, Mode: domain.MergeModeSquash})
 		require.NoError(t, err)
 	})
 		r.seed()
 		head := r.feature("feat")
 		mr := r.open("feat")
-		_, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{})
+		_, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{})
 		require.ErrorIs(t, err, domain.ErrInvalid)
 		assert.Contains(t, fieldsOf(t, err), "head_id")
-		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head, Mode: "rebase"})
+		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head, Mode: "rebase"})
 		require.ErrorIs(t, err, domain.ErrInvalid)
 		assert.Contains(t, fieldsOf(t, err), "mode")
-		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, 99, app.MergeParams{HeadID: head})
+		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, 99, ports.MergeParams{HeadID: head})
 		assert.ErrorIs(t, err, domain.ErrNotFound)
 	})
 		head := r.feature("feat")
 		mr := r.open("feat")
 		r.run(r.bare(), r.env(author), "branch", "-D", "feat")
-		_, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head})
+		_, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head})
 		require.ErrorIs(t, err, domain.ErrPreconditionFailed)
 		assert.Contains(t, err.Error(), "no longer exists")
 		r.push("feat")
 		r.run(r.bare(), r.env(author), "update-ref", "refs/heads/main", head.String())
-		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head})
+		_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head})
 		require.ErrorIs(t, err, domain.ErrPreconditionFailed, "the target already is at the head")
 		assert.Contains(t, err.Error(), "nothing to merge")
 	})
 				continue
 			}
 			wg.Go(func() {
-				_, err := r.mrs.Merge(r.ctx, mrM, r.repo, number, app.MergeParams{HeadID: head, Mode: mode})
+				_, err := r.mrs.Merge(r.ctx, mrM, r.repo, number, ports.MergeParams{HeadID: head, Mode: mode})
 				results <- outcome{number, err}
 			})
 		}
 	r.commit(bob, "w.txt", "w\n", "bob again")
 	r.push("feat")
 	head := r.branchHead("feat")
-	mr, err := r.mrs.Create(r.ctx, root, r.repo, app.CreateMergeRequestParams{Title: "Add things", Source: "feat"})
+	mr, err := r.mrs.Create(r.ctx, root, r.repo, ports.CreateMergeRequestParams{Title: "Add things", Source: "feat"})
 	require.NoError(t, err)
 	r.drain()
-	merged, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: head, Mode: domain.MergeModeSquash})
+	merged, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: head, Mode: domain.MergeModeSquash})
 	require.NoError(t, err)
 	assert.Equal(t, domain.MergeModeSquash, merged.MergeMode)
 	require.False(t, merged.MergedCommitID.IsZero())
 	r.commit(author, "m.txt", "m\n", "only")
 	r.push("mine")
 	mr := r.open("mine")
-	merged, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{HeadID: r.branchHead("mine"), Mode: domain.MergeModeSquash})
+	merged, err := r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{HeadID: r.branchHead("mine"), Mode: domain.MergeModeSquash})
 	require.NoError(t, err)
 	msg := r.run(r.bare(), r.env(author), "log", "-1", "--format=%B", merged.MergedCommitID.String())
 	assert.Equal(t, "Add mine (!1)\n\n- only", msg)
 	modes := []domain.MergeMode{domain.MergeModeSquash, domain.MergeModeSquash}
 	off := false
-	got, err := r.repos.Update(r.ctx, root, r.repo, app.UpdateParams{AllowedMergeModes: &modes, FailingChecksBlock: &off})
+	got, err := r.repos.Update(r.ctx, root, r.repo, ports.UpdateRepoParams{AllowedMergeModes: &modes, FailingChecksBlock: &off})
 	require.NoError(t, err)
 	assert.Equal(t, domain.RepoSettings{AllowedMergeModes: []domain.MergeMode{domain.MergeModeSquash}, FailingChecksBlock: false}, got.Settings)
 	again, err := r.repos.Get(r.ctx, root, r.repo)
 	// Only the named setting changes.
 	on := true
-	got, err = r.repos.Update(r.ctx, root, r.repo, app.UpdateParams{FailingChecksBlock: &on})
+	got, err = r.repos.Update(r.ctx, root, r.repo, ports.UpdateRepoParams{FailingChecksBlock: &on})
 	require.NoError(t, err)
 	assert.Equal(t, []domain.MergeMode{domain.MergeModeSquash}, got.Settings.AllowedMergeModes)
 	assert.True(t, got.Settings.FailingChecksBlock)
 	for _, bad := range [][]domain.MergeMode{{}, nil, {"rebase"}} {
 		bad := bad
-		_, err = r.repos.Update(r.ctx, root, r.repo, app.UpdateParams{AllowedMergeModes: &bad})
+		_, err = r.repos.Update(r.ctx, root, r.repo, ports.UpdateRepoParams{AllowedMergeModes: &bad})
 		assert.ErrorIs(t, err, domain.ErrInvalid, "%v", bad)
 	}
 	again, err = r.repos.Get(r.ctx, root, r.repo)
 	assert.Equal(t, got.Settings, again.Settings, "a refused change stores nothing")
 	// repo:admin is needed, like for any other field.
-	_, err = r.repos.Update(r.ctx, writer(domain.ScopeRepoRead, domain.ScopeMRMerge), r.repo, app.UpdateParams{FailingChecksBlock: &off})
+	_, err = r.repos.Update(r.ctx, writer(domain.ScopeRepoRead, domain.ScopeMRMerge), r.repo, ports.UpdateRepoParams{FailingChecksBlock: &off})
 	assert.ErrorIs(t, err, domain.ErrForbidden)
 }
 	r.open("feat")
 	require.NoError(t, r.repos.Delete(r.ctx, root, r.repo))
-	_, err := r.mrs.List(r.ctx, root, r.repo, app.ListMergeRequestsParams{})
+	_, err := r.mrs.List(r.ctx, root, r.repo, ports.ListMergeRequestsParams{})
 	assert.ErrorIs(t, err, domain.ErrNotFound)
 	// Created again under the same name, it starts empty.
-	_, err = r.repos.Create(r.ctx, root, app.CreateParams{Name: r.repo})
+	_, err = r.repos.Create(r.ctx, root, ports.CreateRepoParams{Name: r.repo})
 	require.NoError(t, err)
-	page, err := r.mrs.List(r.ctx, root, r.repo, app.ListMergeRequestsParams{})
+	page, err := r.mrs.List(r.ctx, root, r.repo, ports.ListMergeRequestsParams{})
 	require.NoError(t, err)
 	assert.Empty(t, page.MergeRequests)
 }
 	r.seed()
 	head := r.feature("feat")
-	mr, err := r.mrs.Create(r.ctx, agent, r.repo, app.CreateMergeRequestParams{Title: "From the agent", Source: "feat"})
+	mr, err := r.mrs.Create(r.ctx, agent, r.repo, ports.CreateMergeRequestParams{Title: "From the agent", Source: "feat"})
 	require.NoError(t, err)
 	assert.Equal(t, head, mr.HeadID)
 	assert.Equal(t, "agent-1", mr.Author)
-	c, err := r.mrs.AddComment(r.ctx, agent, r.repo, mr.Number, app.AddCommentParams{Text: "note"})
+	c, err := r.mrs.AddComment(r.ctx, agent, r.repo, mr.Number, ports.AddCommentParams{Text: "note"})
 	require.NoError(t, err)
 	_, err = r.mrs.ResolveComment(r.ctx, agent, r.repo, mr.Number, c.ID, true)
 	require.NoError(t, err)
 	require.NoError(t, err)
 	// repo:write alone does not read merge requests.
-	_, err = r.mrs.List(r.ctx, agent, r.repo, app.ListMergeRequestsParams{})
+	_, err = r.mrs.List(r.ctx, agent, r.repo, ports.ListMergeRequestsParams{})
 	assert.ErrorIs(t, err, domain.ErrNotFound)
 	_, err = r.mrs.Get(r.ctx, agent, r.repo, mr.Number, false)
 	assert.ErrorIs(t, err, domain.ErrNotFound)
 	assert.Equal(t, domain.MRStateClosed, closed.State)
 	// An unknown repository is not found whatever the scopes.
-	_, err = r.mrs.Create(r.ctx, agent, name(t, "ghost"), app.CreateMergeRequestParams{Title: "t", Source: "feat"})
+	_, err = r.mrs.Create(r.ctx, agent, name(t, "ghost"), ports.CreateMergeRequestParams{Title: "t", Source: "feat"})
 	assert.ErrorIs(t, err, domain.ErrNotFound)
 	// A token limited to other repositories does not get the scope here.
 	elsewhere := domain.TokenPrincipal(domain.Token{ID: "e", Scopes: []domain.Scope{domain.ScopeRepoWrite, domain.ScopeMRWrite}, Repos: []domain.RepoName{name(t, "else")}})
-	_, err = r.mrs.Create(r.ctx, elsewhere, r.repo, app.CreateMergeRequestParams{Title: "t", Source: "feat"})
+	_, err = r.mrs.Create(r.ctx, elsewhere, r.repo, ports.CreateMergeRequestParams{Title: "t", Source: "feat"})
 	assert.ErrorIs(t, err, domain.ErrNotFound)
 }
 			require.True(t, before.PushedAt.IsZero(), "no push recorded yet")
 			assert.Empty(t, r.queued.names())
-			_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, app.MergeParams{Mode: mode, HeadID: head})
+			_, err = r.mrs.Merge(r.ctx, mrM, r.repo, mr.Number, ports.MergeParams{Mode: mode, HeadID: head})
 			require.NoError(t, err)
 			after, err := r.repos.Get(r.ctx, root, r.repo)
 	r.feature("feat")
 	mr := r.open("feat")
 	for i := range app.MaxCommentsPerMergeRequest {
-		_, err := r.mrs.AddComment(r.ctx, mrW, r.repo, mr.Number, app.AddCommentParams{Text: fmt.Sprintf("c%d", i)})
+		_, err := r.mrs.AddComment(r.ctx, mrW, r.repo, mr.Number, ports.AddCommentParams{Text: fmt.Sprintf("c%d", i)})
 		require.NoError(t, err, "comment %d", i+1)
 	}
-	_, err := r.mrs.AddComment(r.ctx, mrW, r.repo, mr.Number, app.AddCommentParams{Text: "one too many"})
+	_, err := r.mrs.AddComment(r.ctx, mrW, r.repo, mr.Number, ports.AddCommentParams{Text: "one too many"})
 	assert.ErrorIs(t, err, domain.ErrResourceExhausted)
 	d, err := r.mrs.Get(r.ctx, root, r.repo, mr.Number, false)
 	require.NoError(t, err)
 	r.commit(author, "o.txt", "o\n", "other")
 	r.push("other")
 	other := r.open("other")
-	_, err = r.mrs.AddComment(r.ctx, mrW, r.repo, other.Number, app.AddCommentParams{Text: "fine"})
+	_, err = r.mrs.AddComment(r.ctx, mrW, r.repo, other.Number, ports.AddCommentParams{Text: "fine"})
 	require.NoError(t, err)
 }

M internal/app/mergerequests_test.go +5 -5

 	"github.com/stretchr/testify/require"
 	"bnema.dev/ermite/internal/app"
-	appmocks "bnema.dev/ermite/internal/app/mocks"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 	"bnema.dev/ermite/internal/ports/mocks"
 )
 	}
 	clock := mocks.NewClock(t)
 	clock.EXPECT().Now().Return(now).Maybe()
-	sched := appmocks.NewMaintenanceScheduler(t)
+	sched := mocks.NewMaintenanceScheduler(t)
 	sched.EXPECT().Schedule(mock.Anything, mock.Anything).Return().Maybe()
 	u.mrs = app.NewMergeRequests(app.MergeRequestsConfig{
 		Meta: u.meta, Store: u.store, Repos: u.repos, Git: u.git,
 func TestCreateReturnsGitFailuresAsErrors(t *testing.T) {
 	t.Parallel()
 	boom := errors.New("fatal: /srv/ermite/repos/proj.git: permission denied")
-	params := app.CreateMergeRequestParams{Title: "t", Source: "feat", Target: "main"}
+	params := ports.CreateMergeRequestParams{Title: "t", Source: "feat", Target: "main"}
 	t.Run("reading a branch", func(t *testing.T) {
 		t.Parallel()
 		u := newMRUnit(t)
 		u.meta.EXPECT().Get(mock.Anything, u.repo.Name).Return(u.repo, nil)
 		u.repos.EXPECT().DefaultBranch(mock.Anything, u.repo.Name).Return("", false, boom)
-		_, err := u.mrs.Create(context.Background(), domain.Root(), u.repo.Name, app.CreateMergeRequestParams{Title: "t", Source: "feat"})
+		_, err := u.mrs.Create(context.Background(), domain.Root(), u.repo.Name, ports.CreateMergeRequestParams{Title: "t", Source: "feat"})
 		require.ErrorIs(t, err, boom)
 		var fe *domain.InvalidFieldsError
 		assert.False(t, errors.As(err, &fe), "not a field violation: %v", err)
 			u.store.EXPECT().Get(mock.Anything, u.repo.Name, int64(1)).Return(domain.MergeRequest{
 				Repo: u.repo.Name, Number: 1, State: domain.MRStateOpen, Source: "feat", Target: "main",
 			}, nil)
-			_, err := u.mrs.Merge(context.Background(), domain.Root(), u.repo.Name, 1, app.MergeParams{HeadID: someID(t)})
+			_, err := u.mrs.Merge(context.Background(), domain.Root(), u.repo.Name, 1, ports.MergeParams{HeadID: someID(t)})
 			require.ErrorIs(t, err, tc.want)
 			if tc.want == boom {
 				assert.NotErrorIs(t, err, domain.ErrNotFound)

M internal/app/paging.go +11 -24

 	"strings"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 const (
 	return page, ""
 }
-// RepoPage is a page of repositories ordered by name.
-type RepoPage struct {
-	Repos []domain.Repo
-	// NextPageToken is empty on the last page.
-	NextPageToken string
-}
 // ListPage returns a page of the repositories the principal may read, ordered
 // by name. size is 0 for DefaultPageSize and lowered to MaxRepoPageSize; the page
 // token names the last repository of the previous page, so repositories that
 // appear or disappear between two pages never shift the others.
-func (r *Repos) ListPage(ctx context.Context, p domain.Principal, size int, token string) (RepoPage, error) {
+func (r *Repos) ListPage(ctx context.Context, p domain.Principal, size int, token string) (ports.RepoPage, error) {
 	n, err := pageSizeUpTo(size, MaxRepoPageSize)
 	if err != nil {
-		return RepoPage{}, err
+		return ports.RepoPage{}, err
 	}
 	after, err := decodeRepoToken(token)
 	if err != nil {
-		return RepoPage{}, err
+		return ports.RepoPage{}, err
 	}
 	all, err := r.List(ctx, p)
 	if err != nil {
-		return RepoPage{}, err
+		return ports.RepoPage{}, err
 	}
-	var page RepoPage
+	var page ports.RepoPage
 	page.Repos, page.NextPageToken = pageAfter(all, n,
 		func(repo domain.Repo) bool { return after == "" || repo.Name.String() > after },
 		func(repo domain.Repo) string { return encodeRepoToken(repo.Name) })
 	return raw, nil
 }
-// TokenPage is a page of stored tokens, newest first.
-type TokenPage struct {
-	Tokens []domain.Token
-	// NextPageToken is empty on the last page.
-	NextPageToken string
-}
 // ListPage returns a page of the tokens List returns, newest first (then by
 // id). size and the page token work like Repos.ListPage; the token names the
 // last token of the previous page.
-func (t *Tokens) ListPage(ctx context.Context, p domain.Principal, size int, token string) (TokenPage, error) {
+func (t *Tokens) ListPage(ctx context.Context, p domain.Principal, size int, token string) (ports.TokenPage, error) {
 	n, err := pageSize(size)
 	if err != nil {
-		return TokenPage{}, err
+		return ports.TokenPage{}, err
 	}
 	after, err := decodeTokenCursor(token)
 	if err != nil {
-		return TokenPage{}, err
+		return ports.TokenPage{}, err
 	}
 	all, err := t.List(ctx, p)
 	if err != nil {
-		return TokenPage{}, err
+		return ports.TokenPage{}, err
 	}
 	slices.SortFunc(all, func(a, b domain.Token) int {
 		if c := b.CreatedAt.Compare(a.CreatedAt); c != 0 {
 		}
 		return strings.Compare(b.ID, a.ID)
 	})
-	var page TokenPage
+	var page ports.TokenPage
 	page.Tokens, page.NextPageToken = pageAfter(all, n,
 		func(tok domain.Token) bool { return after == nil || tokenAfter(tok, *after) },
 		encodeTokenCursor)

M internal/app/pushes.go +9 -15

 // pushRetries bounds the retries of a metadata update that loses a race.
 const pushRetries = 5
-// MaintenanceScheduler queues repository maintenance. *Maintainer fits.
-type MaintenanceScheduler interface {
-	Schedule(ctx context.Context, name domain.RepoName)
-}
-// Revalidator confirms that a principal obtained earlier is still
-// authorized. *Auth fits.
-type Revalidator interface {
-	Revalidate(ctx context.Context, p domain.Principal) error
-}
 // Pushes are the use cases around a Git push.
 type Pushes struct {
 	meta  ports.RepoMetaStore
 	git   ports.GitRepos
 	bus   ports.EventBus
 	clock ports.Clock
-	maint MaintenanceScheduler
+	maint ports.MaintenanceScheduler
-	auth  Revalidator
+	auth  ports.Revalidator
 	fresh ports.RepoFreshener // nil: the reader needs no telling
 }
+var (
+	_ ports.PushService     = (*Pushes)(nil)
+	_ ports.PushHookService = (*Pushes)(nil)
+)
 // NewPushes builds the push use cases. Every argument is required: auth
 // re-validates the token of a push when its pre-receive hook runs, maint
 // queues the maintenance that follows a push.
-func NewPushes(meta ports.RepoMetaStore, repos *Repos, git ports.GitRepos, bus ports.EventBus, clock ports.Clock, maint MaintenanceScheduler, auth Revalidator) *Pushes {
+func NewPushes(meta ports.RepoMetaStore, repos *Repos, git ports.GitRepos, bus ports.EventBus, clock ports.Clock, maint ports.MaintenanceScheduler, auth ports.Revalidator) *Pushes {
 	return &Pushes{meta: meta, repos: repos, git: git, bus: bus, clock: clock, maint: maint, auth: auth}
 }
 	if !create || !canWrite(p, name) {
 		return domain.ErrNotFound
 	}
-	_, err = u.repos.Create(ctx, p, CreateParams{Name: name, Visibility: domain.VisibilityPrivate})
+	_, err = u.repos.Create(ctx, p, ports.CreateRepoParams{Name: name, Visibility: domain.VisibilityPrivate})
 	switch {
 	case err == nil:
 		return nil // Create published RepoCreated

M internal/app/pushes_test.go +2 -3

 	"github.com/stretchr/testify/require"
 	"bnema.dev/ermite/internal/app"
-	appmocks "bnema.dev/ermite/internal/app/mocks"
 	"bnema.dev/ermite/internal/domain"
 	"bnema.dev/ermite/internal/ports"
 	"bnema.dev/ermite/internal/ports/mocks"
 	bus    *mocks.EventBus
 	clock  *mocks.Clock
 	tokens *mocks.TokenStore
-	sched  *appmocks.MaintenanceScheduler
+	sched  *mocks.MaintenanceScheduler
 	pushes *app.Pushes
 }
 		bus:    mocks.NewEventBus(t),
 		clock:  mocks.NewClock(t),
 		tokens: mocks.NewTokenStore(t),
-		sched:  appmocks.NewMaintenanceScheduler(t),
+		sched:  mocks.NewMaintenanceScheduler(t),
 	}
 	f.clock.EXPECT().Now().Return(now).Maybe()
 	repos := app.NewRepos(f.meta, f.git, f.bus, f.clock)

M internal/app/repos.go +3 -9

 	clock ports.Clock
 }
+var _ ports.RepoService = (*Repos)(nil)
 // NewRepos builds the repository use cases over their ports. Changes are
 // published on bus.
 func NewRepos(meta ports.RepoMetaStore, git ports.GitRepos, bus ports.EventBus, clock ports.Clock) *Repos {
 	return &Repos{meta: meta, git: git, bus: bus, clock: clock}
 }
-// CreateParams are the settings of a new repository.
-type CreateParams struct {
-	Name        domain.RepoName
-	Description string
-	// Visibility defaults to private when empty.
-	Visibility domain.Visibility
-}
 // Create makes a repository and publishes RepoCreated: it stages a bare repository, records the
 // metadata (which fails with domain.ErrAlreadyExists if the name is taken,
 // also when a concurrent Create wins) and publishes the directory. A failure
 //
 // The principal needs repo:write on the name: anonymous callers get
 // domain.ErrUnauthenticated, other callers without it domain.ErrForbidden.
-func (r *Repos) Create(ctx context.Context, p domain.Principal, params CreateParams) (domain.Repo, error) {
+func (r *Repos) Create(ctx context.Context, p domain.Principal, params ports.CreateRepoParams) (domain.Repo, error) {
 	if params.Name.IsZero() {
 		return domain.Repo{}, fmt.Errorf("%w: empty name", domain.ErrInvalidName)
 	}

M internal/app/repos_integration_test.go +2 -1

 	"bnema.dev/ermite/internal/adapters/kvstore"
 	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 type fixedClock struct{}
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			_, err := repos.Create(ctx, domain.Root(), app.CreateParams{Name: n})
+			_, err := repos.Create(ctx, domain.Root(), ports.CreateRepoParams{Name: n})
 			errs <- err
 		}()
 	}

M internal/app/repos_test.go +11 -11


@@ -63,7 +63,7 @@ func TestCreate(t *testing.T) {
63		f.git.EXPECT().Publish(ctx, ports.StagedID("s1"), n).Return(nil)	63		f.git.EXPECT().Publish(ctx, ports.StagedID("s1"), n).Return(nil)
64		f.bus.EXPECT().Publish(ctx, domain.RepoCreated{Repo: n, Visibility: domain.VisibilityPrivate, At: now}).Return().Once()	64		f.bus.EXPECT().Publish(ctx, domain.RepoCreated{Repo: n, Visibility: domain.VisibilityPrivate, At: now}).Return().Once()
65			65
66	-	got, err := f.repos.Create(ctx, domain.Root(), app.CreateParams{Name: n, Description: "d"})	66	+	got, err := f.repos.Create(ctx, domain.Root(), ports.CreateRepoParams{Name: n, Description: "d"})
67		require.NoError(t, err)	67		require.NoError(t, err)
68		assert.Equal(t, want, got)	68		assert.Equal(t, want, got)
69		})	69		})

@@ -71,7 +71,7 @@ func TestCreate(t *testing.T) {
71		t.Run("anonymous is refused before anything runs", func(t *testing.T) {	71		t.Run("anonymous is refused before anything runs", func(t *testing.T) {
72		t.Parallel()	72		t.Parallel()
73		f := newFixture(t)	73		f := newFixture(t)
74	-	_, err := f.repos.Create(ctx, domain.Anonymous(), app.CreateParams{Name: name(t, "tools")})	74	+	_, err := f.repos.Create(ctx, domain.Anonymous(), ports.CreateRepoParams{Name: name(t, "tools")})
75		assert.ErrorIs(t, err, domain.ErrUnauthenticated)	75		assert.ErrorIs(t, err, domain.ErrUnauthenticated)
76		})	76		})
77			77

@@ -81,7 +81,7 @@ func TestCreate(t *testing.T) {
81		tokenPrincipal(domain.ScopeRepoWrite, "other"),	81		tokenPrincipal(domain.ScopeRepoWrite, "other"),
82		} {	82		} {
83		f := newFixture(t)	83		f := newFixture(t)
84	-	_, err := f.repos.Create(ctx, p, app.CreateParams{Name: name(t, "tools")})	84	+	_, err := f.repos.Create(ctx, p, ports.CreateRepoParams{Name: name(t, "tools")})
85		assert.ErrorIs(t, err, domain.ErrForbidden)	85		assert.ErrorIs(t, err, domain.ErrForbidden)
86		}	86		}
87		})	87		})

@@ -94,21 +94,21 @@ func TestCreate(t *testing.T) {
94		f.meta.EXPECT().Create(ctx, mock.Anything).Return(nil)	94		f.meta.EXPECT().Create(ctx, mock.Anything).Return(nil)
95		f.git.EXPECT().Publish(ctx, ports.StagedID("s1"), n).Return(nil)	95		f.git.EXPECT().Publish(ctx, ports.StagedID("s1"), n).Return(nil)
96		f.bus.EXPECT().Publish(ctx, mock.Anything).Return().Once()	96		f.bus.EXPECT().Publish(ctx, mock.Anything).Return().Once()
97	-	_, err := f.repos.Create(ctx, tokenPrincipal(domain.ScopeRepoWrite, "tools"), app.CreateParams{Name: n})	97	+	_, err := f.repos.Create(ctx, tokenPrincipal(domain.ScopeRepoWrite, "tools"), ports.CreateRepoParams{Name: n})
98		require.NoError(t, err)	98		require.NoError(t, err)
99		})	99		})
100			100
101		t.Run("zero name is invalid", func(t *testing.T) {	101		t.Run("zero name is invalid", func(t *testing.T) {
102		t.Parallel()	102		t.Parallel()
103		f := newFixture(t)	103		f := newFixture(t)
104	-	_, err := f.repos.Create(ctx, domain.Root(), app.CreateParams{})	104	+	_, err := f.repos.Create(ctx, domain.Root(), ports.CreateRepoParams{})
105		assert.ErrorIs(t, err, domain.ErrInvalidName)	105		assert.ErrorIs(t, err, domain.ErrInvalidName)
106		})	106		})
107			107
108		t.Run("unknown visibility is invalid", func(t *testing.T) {	108		t.Run("unknown visibility is invalid", func(t *testing.T) {
109		t.Parallel()	109		t.Parallel()
110		f := newFixture(t)	110		f := newFixture(t)
111	-	_, err := f.repos.Create(ctx, domain.Root(), app.CreateParams{Name: name(t, "tools"), Visibility: "secret"})	111	+	_, err := f.repos.Create(ctx, domain.Root(), ports.CreateRepoParams{Name: name(t, "tools"), Visibility: "secret"})
112		assert.ErrorIs(t, err, domain.ErrInvalidVisibility)	112		assert.ErrorIs(t, err, domain.ErrInvalidVisibility)
113		})	113		})
114			114

@@ -116,7 +116,7 @@ func TestCreate(t *testing.T) {
116		t.Parallel()	116		t.Parallel()
117		f := newFixture(t)	117		f := newFixture(t)
118		f.git.EXPECT().Stage(ctx).Return("", errBoom)	118		f.git.EXPECT().Stage(ctx).Return("", errBoom)
119	-	_, err := f.repos.Create(ctx, domain.Root(), app.CreateParams{Name: name(t, "tools")})	119	+	_, err := f.repos.Create(ctx, domain.Root(), ports.CreateRepoParams{Name: name(t, "tools")})
120		assert.ErrorIs(t, err, errBoom)	120		assert.ErrorIs(t, err, errBoom)
121		})	121		})
122			122

@@ -126,7 +126,7 @@ func TestCreate(t *testing.T) {
126		f.git.EXPECT().Stage(ctx).Return(ports.StagedID("s1"), nil)	126		f.git.EXPECT().Stage(ctx).Return(ports.StagedID("s1"), nil)
127		f.meta.EXPECT().Create(ctx, mock.Anything).Return(domain.ErrAlreadyExists)	127		f.meta.EXPECT().Create(ctx, mock.Anything).Return(domain.ErrAlreadyExists)
128		f.git.EXPECT().Discard(mock.Anything, ports.StagedID("s1")).Return(nil)	128		f.git.EXPECT().Discard(mock.Anything, ports.StagedID("s1")).Return(nil)
129	-	_, err := f.repos.Create(ctx, domain.Root(), app.CreateParams{Name: name(t, "tools")})	129	+	_, err := f.repos.Create(ctx, domain.Root(), ports.CreateRepoParams{Name: name(t, "tools")})
130		assert.ErrorIs(t, err, domain.ErrAlreadyExists)	130		assert.ErrorIs(t, err, domain.ErrAlreadyExists)
131		})	131		})
132			132

@@ -139,7 +139,7 @@ func TestCreate(t *testing.T) {
139		f.git.EXPECT().Publish(ctx, ports.StagedID("s1"), n).Return(domain.ErrAlreadyExists)	139		f.git.EXPECT().Publish(ctx, ports.StagedID("s1"), n).Return(domain.ErrAlreadyExists)
140		f.meta.EXPECT().Delete(mock.Anything, n).Return(nil)	140		f.meta.EXPECT().Delete(mock.Anything, n).Return(nil)
141		f.git.EXPECT().Discard(mock.Anything, ports.StagedID("s1")).Return(nil)	141		f.git.EXPECT().Discard(mock.Anything, ports.StagedID("s1")).Return(nil)
142	-	_, err := f.repos.Create(ctx, domain.Root(), app.CreateParams{Name: n})	142	+	_, err := f.repos.Create(ctx, domain.Root(), ports.CreateRepoParams{Name: n})
143		assert.ErrorIs(t, err, domain.ErrAlreadyExists)	143		assert.ErrorIs(t, err, domain.ErrAlreadyExists)
144		})	144		})
145			145

@@ -152,7 +152,7 @@ func TestCreate(t *testing.T) {
152		f.git.EXPECT().Publish(ctx, ports.StagedID("s1"), n).Return(errBoom)	152		f.git.EXPECT().Publish(ctx, ports.StagedID("s1"), n).Return(errBoom)
153		f.meta.EXPECT().Delete(mock.Anything, n).Return(nil)	153		f.meta.EXPECT().Delete(mock.Anything, n).Return(nil)
154		f.git.EXPECT().Discard(mock.Anything, ports.StagedID("s1")).Return(nil)	154		f.git.EXPECT().Discard(mock.Anything, ports.StagedID("s1")).Return(nil)
155	-	_, err := f.repos.Create(ctx, domain.Root(), app.CreateParams{Name: n})	155	+	_, err := f.repos.Create(ctx, domain.Root(), ports.CreateRepoParams{Name: n})
156		assert.ErrorIs(t, err, errBoom)	156		assert.ErrorIs(t, err, errBoom)
157		})	157		})
158			158

@@ -174,7 +174,7 @@ func TestCreate(t *testing.T) {
174		f.git.EXPECT().Discard(mock.Anything, ports.StagedID("s1")).RunAndReturn(func(c context.Context, _ ports.StagedID) error {	174		f.git.EXPECT().Discard(mock.Anything, ports.StagedID("s1")).RunAndReturn(func(c context.Context, _ ports.StagedID) error {
175		return c.Err()	175		return c.Err()
176		})	176		})
177	-	_, err := f.repos.Create(cctx, domain.Root(), app.CreateParams{Name: n})	177	+	_, err := f.repos.Create(cctx, domain.Root(), ports.CreateRepoParams{Name: n})
178		assert.ErrorIs(t, err, errBoom)	178		assert.ErrorIs(t, err, errBoom)
179		})	179		})
180		}	180		}

M internal/app/repos_write.go +6 -25

 	"github.com/bnema/zerowrap"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 // MaxDescriptionLen is the longest repository description, in bytes.
 	return nil
 }
-// RepoView is a repository with the Git state that belongs in its summary.
-type RepoView struct {
-	domain.Repo
-	// DefaultBranch is the branch HEAD points to, even when it does not exist
-	// yet; empty when HEAD is detached or the directory is missing.
-	DefaultBranch string
-}
 // View adds the default branch to a repository the caller has already been
 // allowed to see. A repository without a directory has no default branch.
-func (r *Repos) View(ctx context.Context, repo domain.Repo) (RepoView, error) {
+func (r *Repos) View(ctx context.Context, repo domain.Repo) (ports.RepoView, error) {
 	branch, err := r.git.HeadBranch(ctx, repo.Name)
 	if err != nil && !errors.Is(err, domain.ErrNotFound) {
-		return RepoView{}, fmt.Errorf("read default branch of %q: %w", repo.Name, err)
+		return ports.RepoView{}, fmt.Errorf("read default branch of %q: %w", repo.Name, err)
 	}
-	return RepoView{Repo: repo, DefaultBranch: branch}, nil
+	return ports.RepoView{Repo: repo, DefaultBranch: branch}, nil
-}
-// UpdateParams are the changes of Update; a nil field is left alone.
-type UpdateParams struct {
-	Description   *string
-	Visibility    *domain.Visibility
-	DefaultBranch *string
-	// AllowedMergeModes replaces the allowed merge modes; it must hold at
-	// least one known mode.
-	AllowedMergeModes *[]domain.MergeMode
-	// FailingChecksBlock replaces the setting of that name.
-	FailingChecksBlock *bool
 }
 // Update changes the description, the visibility, the default branch and the
 // The metadata is written first, then HEAD, and RepoUpdated is published after
 // both. When only the HEAD move fails, RepoUpdated is still published for the
 // stored metadata and the HEAD error is returned.
-func (r *Repos) Update(ctx context.Context, p domain.Principal, name domain.RepoName, params UpdateParams) (domain.Repo, error) {
+func (r *Repos) Update(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.UpdateRepoParams) (domain.Repo, error) {
 	repo, err := lookupRepo(ctx, r.meta, name)
 	if err != nil {
 		return domain.Repo{}, err
 // 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 UpdateParams) (domain.Repo, error) {
+func (r *Repos) updateMeta(ctx context.Context, name domain.RepoName, params ports.UpdateRepoParams) (domain.Repo, error) {
 	for range pushRetries {
 		repo, err := r.meta.Get(ctx, name)
 		if err != nil {

M internal/app/repos_write_test.go +11 -10

 	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 )
 func ptr[T any](v T) *T { return &v }
 			Repo: n, At: now, Visibility: domain.VisibilityPublic, Previous: domain.VisibilityPrivate,
 		}).Return().Once()
-		got, err := f.repos.Update(ctx, admin, n, app.UpdateParams{
+		got, err := f.repos.Update(ctx, admin, n, ports.UpdateRepoParams{
 			Description: ptr("new"), Visibility: ptr(domain.VisibilityPublic),
 		})
 		require.NoError(t, err)
 		f.meta.EXPECT().Update(ctx, mock.Anything).Return(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, app.UpdateParams{Description: ptr("x")})
+		_, err := f.repos.Update(ctx, admin, n, ports.UpdateRepoParams{Description: ptr("x")})
 		require.NoError(t, err)
 	})
 		f.git.EXPECT().HasBranch(ctx, n, "dev").Return(true, nil)
 		f.git.EXPECT().SetDefaultBranch(ctx, n, "dev").Return(nil)
 		f.bus.EXPECT().Publish(ctx, mock.Anything).Return().Once()
-		got, err := f.repos.Update(ctx, admin, n, app.UpdateParams{DefaultBranch: ptr("dev")})
+		got, err := f.repos.Update(ctx, admin, n, ports.UpdateRepoParams{DefaultBranch: ptr("dev")})
 		require.NoError(t, err)
 		assert.Equal(t, priv, got)
 	})
 			return nil
 		})
 		f.bus.EXPECT().Publish(ctx, mock.Anything).Run(func(context.Context, domain.Event) { order = append(order, "event") }).Return().Once()
-		_, err := f.repos.Update(ctx, admin, n, app.UpdateParams{Description: ptr("x"), DefaultBranch: ptr("dev")})
+		_, err := f.repos.Update(ctx, admin, n, ports.UpdateRepoParams{Description: ptr("x"), DefaultBranch: ptr("dev")})
 		require.NoError(t, err)
 		assert.Equal(t, []string{"meta", "head", "event"}, order)
 	})
 		f.bus.EXPECT().Publish(ctx, domain.RepoUpdated{
 			Repo: n, At: now, Visibility: domain.VisibilityPrivate, Previous: domain.VisibilityPublic,
 		}).Return().Once()
-		_, err := f.repos.Update(ctx, admin, n, app.UpdateParams{Visibility: ptr(domain.VisibilityPrivate), DefaultBranch: ptr("dev")})
+		_, err := f.repos.Update(ctx, admin, n, ports.UpdateRepoParams{Visibility: ptr(domain.VisibilityPrivate), DefaultBranch: ptr("dev")})
 		assert.ErrorIs(t, err, boom)
 	})
 		f.meta.EXPECT().Get(ctx, n).Return(priv, nil)
 		f.git.EXPECT().HasBranch(ctx, n, "dev").Return(true, nil)
 		f.git.EXPECT().SetDefaultBranch(ctx, n, "dev").Return(boom)
-		_, err := f.repos.Update(ctx, admin, n, app.UpdateParams{DefaultBranch: ptr("dev")})
+		_, err := f.repos.Update(ctx, admin, n, ports.UpdateRepoParams{DefaultBranch: ptr("dev")})
 		assert.ErrorIs(t, err, boom)
 	})
 		f := newFixture(t)
 		f.meta.EXPECT().Get(ctx, n).Return(priv, nil)
 		f.git.EXPECT().HasBranch(ctx, n, "nope").Return(false, nil)
-		_, err := f.repos.Update(ctx, admin, n, app.UpdateParams{Description: ptr("x"), DefaultBranch: ptr("nope")})
+		_, err := f.repos.Update(ctx, admin, n, ports.UpdateRepoParams{Description: ptr("x"), DefaultBranch: ptr("nope")})
 		assert.ErrorIs(t, err, domain.ErrPreconditionFailed)
 	})
 	t.Run("invalid input changes nothing", func(t *testing.T) {
-		for name, params := range map[string]app.UpdateParams{
+		for name, params := range map[string]ports.UpdateRepoParams{
 			"empty":             {},
 			"empty branch":      {DefaultBranch: ptr("")},
 			"multi-line":        {Description: ptr("a\nb")},
 			t.Parallel()
 			f := newFixture(t)
 			f.meta.EXPECT().Get(ctx, n).Return(tt.repo, nil)
-			_, err := f.repos.Update(ctx, tt.p, n, app.UpdateParams{Description: ptr("x")})
+			_, err := f.repos.Update(ctx, tt.p, n, ports.UpdateRepoParams{Description: ptr("x")})
 			assert.ErrorIs(t, err, tt.want)
 			err = f.repos.Delete(ctx, tt.p, n)
 			assert.ErrorIs(t, err, tt.want)
 		t.Parallel()
 		f := newFixture(t)
 		f.meta.EXPECT().Get(ctx, n).Return(domain.Repo{}, domain.ErrNotFound)
-		_, err := f.repos.Update(ctx, domain.Root(), n, app.UpdateParams{Description: ptr("x")})
+		_, err := f.repos.Update(ctx, domain.Root(), n, ports.UpdateRepoParams{Description: ptr("x")})
 		assert.ErrorIs(t, err, domain.ErrNotFound)
 	})
 }

M internal/app/sessions.go +7 -12

 	LoginPath = "/-/login/"
 )
-// LoginLink is a login link as the owner receives it.
-type LoginLink struct {
-	// URL holds the secret: show it once, never log it.
-	URL       string
-	ExpiresAt time.Time
-}
 // Sessions are the use cases of the owner's browser sessions: login links,
 // session tokens and signing out everywhere. Login links live in memory only,
 // so a restart voids them; the signing key and the epoch are in the store.
 	links map[[sha256.Size]byte]pendingLink // by hash of the nonce
 }
+var _ ports.SessionService = (*Sessions)(nil)
 // pendingLink is a login link that waits to be used.
 type pendingLink struct {
 	expires time.Time
 // created it: it is capped at that token's expiry (no cap for root, or a token
 // that never expires). It gives domain.ErrResourceExhausted when MaxPendingLoginLinks
 // links wait. The nonce is never logged.
-func (s *Sessions) CreateLoginLink(ctx context.Context, p domain.Principal) (LoginLink, error) {
+func (s *Sessions) CreateLoginLink(ctx context.Context, p domain.Principal) (ports.LoginLink, error) {
 	if err := requireOwner(p); err != nil {
-		return LoginLink{}, err
+		return ports.LoginLink{}, err
 	}
 	var raw [loginNonceBytes]byte
 	if _, err := rand.Read(raw[:]); err != nil {
-		return LoginLink{}, fmt.Errorf("generate login link: %w", err)
+		return ports.LoginLink{}, fmt.Errorf("generate login link: %w", err)
 	}
 	nonce := base64.RawURLEncoding.EncodeToString(raw[:])
 	now := s.clock.Now()
 	}
 	if len(s.links) >= MaxPendingLoginLinks {
 		s.mu.Unlock()
-		return LoginLink{}, fmt.Errorf("%w: %d login links are already pending, use one or wait a minute", domain.ErrResourceExhausted, MaxPendingLoginLinks)
+		return ports.LoginLink{}, fmt.Errorf("%w: %d login links are already pending, use one or wait a minute", domain.ErrResourceExhausted, MaxPendingLoginLinks)
 	}
 	s.links[sha256.Sum256([]byte(nonce))] = pendingLink{expires: exp, sessionCap: p.ExpiresAt()}
 	s.mu.Unlock()
 	log := zerowrap.FromCtx(ctx)
 	log.Info().Str("created_by", p.Label()).Str("created_by_token", p.TokenID()).Time("expires_at", exp).Msg("login link created")
-	return LoginLink{URL: s.publicURL + LoginPath + nonce, ExpiresAt: exp.UTC()}, nil
+	return ports.LoginLink{URL: s.publicURL + LoginPath + nonce, ExpiresAt: exp.UTC()}, nil
 }
 // LoginLinkValid reports whether the nonce is a pending link, without using

M internal/app/signing.go +2 -0


@@ -14,6 +14,8 @@ type SigningKey struct {
14	committer domain.Identity	14		committer domain.Identity
15	}	15		}
16		16
		17	+	var _ ports.SigningKeyService = (*SigningKey)(nil)
		18	+
17	// NewSigningKey builds the use case over the signer and the identity recorded	19		// NewSigningKey builds the use case over the signer and the identity recorded
18	// as the committer of the signed commits.	20		// as the committer of the signed commits.
19	func NewSigningKey(signer ports.CommitSigner, committer domain.Identity) *SigningKey {	21		func NewSigningKey(signer ports.CommitSigner, committer domain.Identity) *SigningKey {

M internal/app/tokens.go +16 -27

 	sessions ports.SessionStore
 }
+var _ ports.TokenService = (*Tokens)(nil)
 // NewTokens builds the token use cases over their ports. sessions is where
 // revoking a token with owner rights ends every web session (see Revoke).
 func NewTokens(store ports.TokenStore, clock ports.Clock, sessions ports.SessionStore) *Tokens {
 	return &Tokens{store: store, clock: clock, sessions: sessions}
 }
-// CreateTokenParams are the settings of a new token.
-type CreateTokenParams struct {
-	Label string
-	// Scopes must not be empty.
-	Scopes []domain.Scope
-	// Repos limits the token to these repositories; empty means every one.
-	Repos []domain.RepoName
-	// ExpiresAt is the zero time for a token that never expires.
-	ExpiresAt time.Time
-}
-// CreatedToken is a new token with its secret, which is shown once and never
-// stored.
-type CreatedToken struct {
-	Token  domain.Token
-	Secret string
-}
 // Create makes a stored token and returns it with its secret.
 //
 // The principal needs token:admin: anonymous callers get
 // domain.ErrInvalidToken (this includes the labels "owner" and "root", which
 // are reserved, in any case and around spaces), an unknown scope
 // domain.ErrInvalidScope.
-func (t *Tokens) Create(ctx context.Context, p domain.Principal, params CreateTokenParams) (CreatedToken, error) {
+func (t *Tokens) Create(ctx context.Context, p domain.Principal, params ports.CreateTokenParams) (ports.CreatedToken, error) {
 	if p.IsAnonymous() {
-		return CreatedToken{}, domain.ErrUnauthenticated
+		return ports.CreatedToken{}, domain.ErrUnauthenticated
 	}
 	if !canManageTokens(p) {
-		return CreatedToken{}, fmt.Errorf("%w: creating tokens needs %s", domain.ErrForbidden, domain.ScopeTokenAdmin)
+		return ports.CreatedToken{}, fmt.Errorf("%w: creating tokens needs %s", domain.ErrForbidden, domain.ScopeTokenAdmin)
 	}
 	now := t.clock.Now().UTC()
 	tok, err := buildToken(params, now)
 	if err != nil {
-		return CreatedToken{}, err
+		return ports.CreatedToken{}, err
 	}
 	if err := checkNoEscalation(p, tok); err != nil {
-		return CreatedToken{}, err
+		return ports.CreatedToken{}, err
 	}
 	for range 3 {
 			continue // a random id or secret collided: practically never
 		}
 		if err != nil {
-			return CreatedToken{}, fmt.Errorf("store token: %w", err)
+			return ports.CreatedToken{}, fmt.Errorf("store token: %w", err)
 		}
 		log := zerowrap.FromCtx(ctx)
 		log.Info().
 			Int("scopes", len(tok.Scopes)).Int("repos", len(tok.Repos)).
 			Str("created_by", p.Label()).Str("created_by_token", p.TokenID()).
 			Msg("token created")
-		return CreatedToken{Token: tok, Secret: secret}, nil
+		return ports.CreatedToken{Token: tok, Secret: secret}, nil
 	}
-	return CreatedToken{}, errors.New("store token: could not find a free id")
+	return ports.CreatedToken{}, errors.New("store token: could not find a free id")
 }
 // buildToken validates the settings and returns the token without id and hash.
-func buildToken(params CreateTokenParams, now time.Time) (domain.Token, error) {
+func buildToken(params ports.CreateTokenParams, now time.Time) (domain.Token, error) {
 	if params.Label == "" || len(params.Label) > MaxTokenLabelLen || !utf8.ValidString(params.Label) {
 		return domain.Token{}, fmt.Errorf("%w: label must be 1 to %d bytes of UTF-8", domain.ErrInvalidToken, MaxTokenLabelLen)
 	}
 	clock  ports.Clock
 }
+var (
+	_ ports.AuthService = (*Auth)(nil)
+	_ ports.Revalidator = (*Auth)(nil)
+)
 // NewAuth builds the authentication use case. rootHash is the SHA-256 of the
 // admin token.
 func NewAuth(rootHash domain.TokenHash, tokens ports.TokenStore, clock ports.Clock) *Auth {

M internal/app/tokens_test.go +35 -34

 	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 	"bnema.dev/ermite/internal/ports/mocks"
 )
 			t.Parallel()
 			f := newTokenFixture(t)
 			f.store.EXPECT().Create(ctx, mock.Anything).Return(nil)
-			_, err := f.tokens.Create(ctx, domain.Root(), app.CreateTokenParams{Label: tt.label, Scopes: scopes(domain.ScopeRepoRead)})
+			_, err := f.tokens.Create(ctx, domain.Root(), ports.CreateTokenParams{Label: tt.label, Scopes: scopes(domain.ScopeRepoRead)})
 			assert.NoError(t, err)
 		})
 	}
 		f.store.EXPECT().Create(ctx, mock.Anything).Run(func(_ context.Context, tok domain.Token) { stored = tok }).Return(nil)
 		exp := now.Add(48 * time.Hour)
-		got, err := f.tokens.Create(ctx, domain.Root(), app.CreateTokenParams{
+		got, err := f.tokens.Create(ctx, domain.Root(), ports.CreateTokenParams{
 			Label:     "ci",
 			Scopes:    scopes(domain.ScopeRepoWrite, domain.ScopeRepoRead, domain.ScopeRepoRead),
 			Repos:     names(t, "b", "a", "b"),
 		t.Parallel()
 		f := newTokenFixture(t)
 		f.store.EXPECT().Create(ctx, mock.Anything).Return(nil)
-		a, err := f.tokens.Create(ctx, domain.Root(), app.CreateTokenParams{Label: "a", Scopes: scopes(domain.ScopeRepoRead)})
+		a, err := f.tokens.Create(ctx, domain.Root(), ports.CreateTokenParams{Label: "a", Scopes: scopes(domain.ScopeRepoRead)})
 		require.NoError(t, err)
-		b, err := f.tokens.Create(ctx, domain.Root(), app.CreateTokenParams{Label: "a", Scopes: scopes(domain.ScopeRepoRead)})
+		b, err := f.tokens.Create(ctx, domain.Root(), ports.CreateTokenParams{Label: "a", Scopes: scopes(domain.ScopeRepoRead)})
 		require.NoError(t, err)
 		assert.NotEqual(t, a.Secret, b.Secret)
 		assert.NotEqual(t, a.Token.ID, b.Token.ID)
 		f := newTokenFixture(t)
 		f.store.EXPECT().Create(ctx, mock.Anything).Return(domain.ErrAlreadyExists).Once()
 		f.store.EXPECT().Create(ctx, mock.Anything).Return(nil).Once()
-		_, err := f.tokens.Create(ctx, domain.Root(), app.CreateTokenParams{Label: "a", Scopes: scopes(domain.ScopeRepoRead)})
+		_, err := f.tokens.Create(ctx, domain.Root(), ports.CreateTokenParams{Label: "a", Scopes: scopes(domain.ScopeRepoRead)})
 		require.NoError(t, err)
 	})
 		f := newTokenFixture(t)
 		boom := errors.New("boom")
 		f.store.EXPECT().Create(ctx, mock.Anything).Return(boom)
-		_, err := f.tokens.Create(ctx, domain.Root(), app.CreateTokenParams{Label: "a", Scopes: scopes(domain.ScopeRepoRead)})
+		_, err := f.tokens.Create(ctx, domain.Root(), ports.CreateTokenParams{Label: "a", Scopes: scopes(domain.ScopeRepoRead)})
 		assert.ErrorIs(t, err, boom)
 	})
 	invalid := []struct {
 		name   string
-		params app.CreateTokenParams
+		params ports.CreateTokenParams
 		want   error
 	}{
-		{"empty label", app.CreateTokenParams{Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrInvalidToken},
+		{"empty label", ports.CreateTokenParams{Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrInvalidToken},
-		{"long label", app.CreateTokenParams{Label: strings.Repeat("x", 101), Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrInvalidToken},
+		{"long label", ports.CreateTokenParams{Label: strings.Repeat("x", 101), Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrInvalidToken},
-		{"bad utf8 label", app.CreateTokenParams{Label: "\xff", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrInvalidToken},
+		{"bad utf8 label", ports.CreateTokenParams{Label: "\xff", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrInvalidToken},
-		{"reserved owner", app.CreateTokenParams{Label: "owner", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrInvalidToken},
+		{"reserved owner", ports.CreateTokenParams{Label: "owner", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrInvalidToken},
-		{"reserved root", app.CreateTokenParams{Label: "root", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrInvalidToken},
+		{"reserved root", ports.CreateTokenParams{Label: "root", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrInvalidToken},
-		{"reserved, upper case", app.CreateTokenParams{Label: "OWNER", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrInvalidToken},
+		{"reserved, upper case", ports.CreateTokenParams{Label: "OWNER", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrInvalidToken},
-		{"reserved, mixed case", app.CreateTokenParams{Label: "Root", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrInvalidToken},
+		{"reserved, mixed case", ports.CreateTokenParams{Label: "Root", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrInvalidToken},
-		{"reserved, padded", app.CreateTokenParams{Label: " \towner \n", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrInvalidToken},
+		{"reserved, padded", ports.CreateTokenParams{Label: " \towner \n", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrInvalidToken},
-		{"no scopes", app.CreateTokenParams{Label: "x"}, domain.ErrInvalidToken},
+		{"no scopes", ports.CreateTokenParams{Label: "x"}, domain.ErrInvalidToken},
-		{"unknown scope", app.CreateTokenParams{Label: "x", Scopes: scopes("nope")}, domain.ErrInvalidScope},
+		{"unknown scope", ports.CreateTokenParams{Label: "x", Scopes: scopes("nope")}, domain.ErrInvalidScope},
-		{"past expiry", app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead), ExpiresAt: now}, domain.ErrInvalidToken},
+		{"past expiry", ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead), ExpiresAt: now}, domain.ErrInvalidToken},
-		{"zero repo name", app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead), Repos: []domain.RepoName{{}}}, domain.ErrInvalidToken},
+		{"zero repo name", ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead), Repos: []domain.RepoName{{}}}, domain.ErrInvalidToken},
 	}
 	for _, tt := range invalid {
 		t.Run("invalid/"+tt.name, func(t *testing.T) {
 	tests := []struct {
 		name      string
 		principal domain.Principal
-		params    app.CreateTokenParams
+		params    ports.CreateTokenParams
 		want      error // nil = allowed
 	}{
-		{"anonymous", domain.Anonymous(), app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrUnauthenticated},
+		{"anonymous", domain.Anonymous(), ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrUnauthenticated},
 		{"token without token:admin",
 			domain.TokenPrincipal(domain.Token{Scopes: scopes(domain.ScopeRepoWrite)}),
-			app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrForbidden},
+			ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrForbidden},
 		{"subset of scopes", admin(nil, time.Time{}),
-			app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead)}, nil},
+			ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead)}, nil},
 		{"same scopes incl. token:admin", admin(nil, time.Time{}),
-			app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeTokenAdmin, domain.ScopeRepoWrite)}, nil},
+			ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeTokenAdmin, domain.ScopeRepoWrite)}, nil},
 		{"scope it lacks", admin(nil, time.Time{}),
-			app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead, domain.ScopeRepoAdmin)}, domain.ErrForbidden},
+			ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead, domain.ScopeRepoAdmin)}, domain.ErrForbidden},
 		{"limited creator, same repos", admin(names(t, "a", "b"), time.Time{}),
-			app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead), Repos: names(t, "a")}, nil},
+			ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead), Repos: names(t, "a")}, nil},
 		{"limited creator, repo outside its list", admin(names(t, "a"), time.Time{}),
-			app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead), Repos: names(t, "a", "z")}, domain.ErrForbidden},
+			ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead), Repos: names(t, "a", "z")}, domain.ErrForbidden},
 		{"limited creator, unlimited child", admin(names(t, "a"), time.Time{}),
-			app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrForbidden},
+			ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrForbidden},
 		{"unlimited creator may limit", admin(nil, time.Time{}),
-			app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead), Repos: names(t, "z")}, nil},
+			ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead), Repos: names(t, "z")}, nil},
 		{"expiring creator, child never expires", admin(nil, exp),
-			app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrForbidden},
+			ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead)}, domain.ErrForbidden},
 		{"expiring creator, child outlasts", admin(nil, exp),
-			app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead), ExpiresAt: exp.Add(time.Second)}, domain.ErrForbidden},
+			ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead), ExpiresAt: exp.Add(time.Second)}, domain.ErrForbidden},
 		{"expiring creator, child within", admin(nil, exp),
-			app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead), ExpiresAt: exp.Add(-time.Second)}, nil},
+			ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead), ExpiresAt: exp.Add(-time.Second)}, nil},
 		{"expiring creator, child same expiry", admin(nil, exp),
-			app.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead), ExpiresAt: exp}, nil},
+			ports.CreateTokenParams{Label: "x", Scopes: scopes(domain.ScopeRepoRead), ExpiresAt: exp}, nil},
 		{"root: everything", domain.Root(),
-			app.CreateTokenParams{Label: "x", Scopes: domain.AllScopes()}, nil},
+			ports.CreateTokenParams{Label: "x", Scopes: domain.AllScopes()}, nil},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

M internal/clientlimit/limiter.go +4 -0


@@ -16,6 +16,8 @@ import (
16	"time"	16		"time"
17		17
18	"github.com/bnema/zerowrap"	18		"github.com/bnema/zerowrap"
		19	+
		20	+	"bnema.dev/ermite/internal/ports"
19	)	21		)
20		22
21	// Limiter defaults: 10 failed authentications in 10 minutes block the client	23		// Limiter defaults: 10 failed authentications in 10 minutes block the client

@@ -54,6 +56,8 @@ type Limiter struct {
54	lastSweep time.Time	56		lastSweep time.Time
55	}	57		}
56		58
		59	+	var _ ports.FailureLimiter = (*Limiter)(nil)
		60	+
57	// NewLimiter builds a limiter. now defaults to time.Now.	61		// NewLimiter builds a limiter. now defaults to time.Now.
58	func NewLimiter(now func() time.Time) *Limiter {	62		func NewLimiter(now func() time.Time) *Limiter {
59	if now == nil {	63		if now == nil {

A internal/ports/dto.go +228 -0

@@ -0,0 +1,228 @@
	1	+	// SPDX-License-Identifier: AGPL-3.0-or-later
	2	+
	3	+	package ports
	4	+
	5	+	import (
	6	+	"time"
	7	+
	8	+	"bnema.dev/ermite/internal/domain"
	9	+	)
	10	+
	11	+	// The parameters and results of the use case interfaces (services.go). They
	12	+	// live here so that the adapters that call the use cases and the use cases
	13	+	// themselves share them without importing each other.
	14	+
	15	+	// RepoPage is a page of repositories ordered by name.
	16	+	type RepoPage struct {
	17	+	Repos []domain.Repo
	18	+	// NextPageToken is empty on the last page.
	19	+	NextPageToken string
	20	+	}
	21	+
	22	+	// RepoView is a repository with the Git state that belongs in its summary.
	23	+	type RepoView struct {
	24	+	domain.Repo
	25	+	// DefaultBranch is the branch HEAD points to, even when it does not exist
	26	+	// yet; empty when HEAD is detached or the directory is missing.
	27	+	DefaultBranch string
	28	+	}
	29	+
	30	+	// CreateRepoParams are the settings of a new repository.
	31	+	type CreateRepoParams struct {
	32	+	Name domain.RepoName
	33	+	Description string
	34	+	// Visibility defaults to private when empty.
	35	+	Visibility domain.Visibility
	36	+	}
	37	+
	38	+	// UpdateRepoParams are the changes of Update; a nil field is left alone.
	39	+	type UpdateRepoParams struct {
	40	+	Description *string
	41	+	Visibility *domain.Visibility
	42	+	DefaultBranch *string
	43	+	// AllowedMergeModes replaces the allowed merge modes; it must hold at
	44	+	// least one known mode.
	45	+	AllowedMergeModes *[]domain.MergeMode
	46	+	// FailingChecksBlock replaces the setting of that name.
	47	+	FailingChecksBlock *bool
	48	+	}
	49	+
	50	+	// TokenPage is a page of stored tokens, newest first.
	51	+	type TokenPage struct {
	52	+	Tokens []domain.Token
	53	+	// NextPageToken is empty on the last page.
	54	+	NextPageToken string
	55	+	}
	56	+
	57	+	// CreateTokenParams are the settings of a new token.
	58	+	type CreateTokenParams struct {
	59	+	Label string
	60	+	// Scopes must not be empty.
	61	+	Scopes []domain.Scope
	62	+	// Repos limits the token to these repositories; empty means every one.
	63	+	Repos []domain.RepoName
	64	+	// ExpiresAt is the zero time for a token that never expires.
	65	+	ExpiresAt time.Time
	66	+	}
	67	+
	68	+	// CreatedToken is a new token with its secret, which is shown once and never
	69	+	// stored.
	70	+	type CreatedToken struct {
	71	+	Token domain.Token
	72	+	Secret string
	73	+	}
	74	+
	75	+	// ListRefsParams selects the refs to list.
	76	+	type ListRefsParams struct {
	77	+	// Kinds restricts the result; empty means every kind.
	78	+	Kinds []domain.RefKind
	79	+	// PageSize is 0 for the default, and lowered to MaxRefPageSize.
	80	+	PageSize int
	81	+	// PageToken is the NextPageToken of the previous page, or empty.
	82	+	PageToken string
	83	+	}
	84	+
	85	+	// RefPage is a page of refs.
	86	+	type RefPage struct {
	87	+	Refs []domain.Ref
	88	+	// NextPageToken is empty on the last page.
	89	+	NextPageToken string
	90	+	}
	91	+
	92	+	// ListCommitsParams selects a page of history.
	93	+	type ListCommitsParams struct {
	94	+	// Revision is where the history starts; the zero value is HEAD. Ignored
	95	+	// when PageToken is set: the token pins the commit the first page started
	96	+	// from, so every page walks the same history even if a branch moves.
	97	+	Revision domain.Revision
	98	+	// Path limits the history to the commits that changed it. It must be the
	99	+	// same on every page of a listing.
	100	+	Path domain.TreePath
	101	+	// PageSize is 0 for the default, and lowered to MaxPageSize.
	102	+	PageSize int
	103	+	// PageToken is the NextPageToken of the previous page, or empty.
	104	+	PageToken string
	105	+	}
	106	+
	107	+	// HistoryPage is a page of history, newest first.
	108	+	type HistoryPage struct {
	109	+	Commits []domain.Commit
	110	+	// NextPageToken is empty on the last page.
	111	+	NextPageToken string
	112	+	}
	113	+
	114	+	// WatchParams select the events of a watch.
	115	+	type WatchParams struct {
	116	+	// Topics are TopicHome or "repo:<name>"; empty means TopicHome.
	117	+	Topics []string
	118	+	// ResumeAfter is the id of the last event the caller saw; empty to
	119	+	// receive only new events.
	120	+	ResumeAfter string
	121	+	// Client identifies where the watch comes from, for the limit per client
	122	+	// (MaxWatchersPerClient): an opaque key such as a normalized address; the
	123	+	// web passes its visitor's. Empty only for callers with no client, which
	124	+	// count against MaxWatchers alone.
	125	+	Client string
	126	+	// Ready, when not nil, is called once the topics are valid and the watch
	127	+	// is registered: events published from then on are not missed. Nothing is
	128	+	// sent before it returns.
	129	+	Ready func()
	130	+	}
	131	+
	132	+	// WatchEvent is one item of a watch.
	133	+	type WatchEvent struct {
	134	+	// ID identifies the event, for resuming. Empty on a gap.
	135	+	ID string
	136	+	// Gap tells that events were lost: the caller must reload what it shows.
	137	+	// Event is nil then.
	138	+	Gap bool
	139	+	// Event is a domain.RepoCreated, RepoUpdated, RepoDeleted, PushEvent,
	140	+	// MergeRequestOpened, MergeRequestMerged, MergeRequestClosed or
	141	+	// CommentAdded.
	142	+	Event domain.Event
	143	+	// Repo is the state of the repository at delivery, for RepoCreated and
	144	+	// RepoUpdated.
	145	+	Repo *RepoView
	146	+	}
	147	+
	148	+	// CreateMergeRequestParams describes the merge request to open.
	149	+	type CreateMergeRequestParams struct {
	150	+	Title string
	151	+	Description string
	152	+	// Source is required; Target defaults to the default branch.
	153	+	Source, Target string
	154	+	}
	155	+
	156	+	// ListMergeRequestsParams selects a page of merge requests.
	157	+	type ListMergeRequestsParams struct {
	158	+	// State restricts the result; empty means every state.
	159	+	State domain.MRState
	160	+	// PageSize is 0 for the default, and lowered to MaxPageSize.
	161	+	PageSize int
	162	+	// PageToken is the NextPageToken of the previous page, or empty.
	163	+	PageToken string
	164	+	}
	165	+
	166	+	// MergeRequestPage is a page of merge requests, highest number first.
	167	+	type MergeRequestPage struct {
	168	+	MergeRequests []domain.MergeRequest
	169	+	// NextPageToken is empty on the last page.
	170	+	NextPageToken string
	171	+	}
	172	+
	173	+	// MergeRequestDetail is a merge request with its review data.
	174	+	type MergeRequestDetail struct {
	175	+	MergeRequest domain.MergeRequest
	176	+	// Commits are the commits of the head that the target lacks, newest
	177	+	// first, at most MaxMergeRequestCommits.
	178	+	Commits []domain.Commit
	179	+	CommitsTruncated bool
	180	+	// DiffBaseID is the commit the diff compares from; zero when the source
	181	+	// branch is gone, then the diff is empty.
	182	+	DiffBaseID domain.ObjectID
	183	+	Stats domain.DiffStats
	184	+	Diff domain.Diff
	185	+	// Comments are the comments, oldest first.
	186	+	Comments []domain.Comment
	187	+	// LastReadID is the head recorded by MarkRead; zero when none.
	188	+	LastReadID domain.ObjectID
	189	+	// LastReadLost tells that since-last-read was asked for, a head was
	190	+	// recorded, but that commit is gone: the diff is against the target.
	191	+	LastReadLost bool
	192	+	}
	193	+
	194	+	// AddCommentParams describes the comment to add.
	195	+	type AddCommentParams struct {
	196	+	// Path, Line and Side designate a line of the diff; all empty for a
	197	+	// general comment.
	198	+	Path string
	199	+	Line int
	200	+	Side domain.DiffSide
	201	+	Text string
	202	+	}
	203	+
	204	+	// MergeParams describes the merge to perform.
	205	+	type MergeParams struct {
	206	+	// Mode defaults to fast-forward.
	207	+	Mode domain.MergeMode
	208	+	// HeadID is the commit the caller reviewed; the source branch must still
	209	+	// point to it.
	210	+	HeadID domain.ObjectID
	211	+	// DeleteSource deletes the source branch after the merge.
	212	+	DeleteSource bool
	213	+	}
	214	+
	215	+	// MergeResult is a merged request and what happened to its source branch.
	216	+	type MergeResult struct {
	217	+	domain.MergeRequest
	218	+	// SourceDeleted is true when DeleteSource was asked and the branch is
	219	+	// gone.
	220	+	SourceDeleted bool
	221	+	}
	222	+
	223	+	// LoginLink is a login link as the owner receives it.
	224	+	type LoginLink struct {
	225	+	// URL holds the secret: show it once, never log it.
	226	+	URL string
	227	+	ExpiresAt time.Time
	228	+	}

R internal/adapters/githttp/mocks/Authenticator.go → internal/ports/mocks/AuthService.go +18 -18 renamed, 52% similar


@@ -11,17 +11,17 @@ import (
11		mock "github.com/stretchr/testify/mock"	11		mock "github.com/stretchr/testify/mock"
12		)	12		)
13			13
14	-	// NewAuthenticator creates a new instance of Authenticator. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.	14	+	// NewAuthService creates a new instance of AuthService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15		// The first argument is typically a *testing.T value.	15		// The first argument is typically a *testing.T value.
16	-	func NewAuthenticator(t interface {	16	+	func NewAuthService(t interface {
17		mock.TestingT	17		mock.TestingT
18		Cleanup(func())	18		Cleanup(func())
19	-	}) *Authenticator {	19	+	}) *AuthService {
20		if helper, ok := t.(interface{ Helper() }); ok {	20		if helper, ok := t.(interface{ Helper() }); ok {
21		helper.Helper()	21		helper.Helper()
22		}	22		}
23			23
24	-	mock := &Authenticator{}	24	+	mock := &AuthService{}
25		mock.Mock.Test(t)	25		mock.Mock.Test(t)
26			26
27		t.Cleanup(func() {	27		t.Cleanup(func() {

@@ -34,21 +34,21 @@ func NewAuthenticator(t interface {
34		return mock	34		return mock
35		}	35		}
36			36
37	-	// Authenticator is an autogenerated mock type for the Authenticator type	37	+	// AuthService is an autogenerated mock type for the AuthService type
38	-	type Authenticator struct {	38	+	type AuthService struct {
39		mock.Mock	39		mock.Mock
40		}	40		}
41			41
42	-	type Authenticator_Expecter struct {	42	+	type AuthService_Expecter struct {
43		mock *mock.Mock	43		mock *mock.Mock
44		}	44		}
45			45
46	-	func (_m Authenticator) EXPECT() Authenticator_Expecter {	46	+	func (_m AuthService) EXPECT() AuthService_Expecter {
47	-	return &Authenticator_Expecter{mock: &_m.Mock}	47	+	return &AuthService_Expecter{mock: &_m.Mock}
48		}	48		}
49			49
50	-	// Authenticate provides a mock function for the type Authenticator	50	+	// Authenticate provides a mock function for the type AuthService
51	-	func (_mock *Authenticator) Authenticate(ctx context.Context, secret string) (domain.Principal, error) {	51	+	func (_mock *AuthService) Authenticate(ctx context.Context, secret string) (domain.Principal, error) {
52		ret := _mock.Called(ctx, secret)	52		ret := _mock.Called(ctx, secret)
53			53
54		if len(ret) == 0 {	54		if len(ret) == 0 {

@@ -73,19 +73,19 @@ func (_mock *Authenticator) Authenticate(ctx context.Context, secret string) (do
73		return r0, r1	73		return r0, r1
74		}	74		}
75			75
76	-	// Authenticator_Authenticate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Authenticate'	76	+	// AuthService_Authenticate_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Authenticate'
77	-	type Authenticator_Authenticate_Call struct {	77	+	type AuthService_Authenticate_Call struct {
78		*mock.Call	78		*mock.Call
79		}	79		}
80			80
81		// Authenticate is a helper method to define mock.On call	81		// Authenticate is a helper method to define mock.On call
82		// - ctx context.Context	82		// - ctx context.Context
83		// - secret string	83		// - secret string
84	-	func (_e Authenticator_Expecter) Authenticate(ctx any, secret any) Authenticator_Authenticate_Call {	84	+	func (_e AuthService_Expecter) Authenticate(ctx any, secret any) AuthService_Authenticate_Call {
85	-	return &Authenticator_Authenticate_Call{Call: _e.mock.On("Authenticate", ctx, secret)}	85	+	return &AuthService_Authenticate_Call{Call: _e.mock.On("Authenticate", ctx, secret)}
86		}	86		}
87			87
88	-	func (_c Authenticator_Authenticate_Call) Run(run func(ctx context.Context, secret string)) Authenticator_Authenticate_Call {	88	+	func (_c AuthService_Authenticate_Call) Run(run func(ctx context.Context, secret string)) AuthService_Authenticate_Call {
89		_c.Call.Run(func(args mock.Arguments) {	89		_c.Call.Run(func(args mock.Arguments) {
90		var arg0 context.Context	90		var arg0 context.Context
91		if args[0] != nil {	91		if args[0] != nil {

@@ -103,12 +103,12 @@ func (_c *Authenticator_Authenticate_Call) Run(run func(ctx context.Context, sec
103		return _c	103		return _c
104		}	104		}
105			105
106	-	func (_c Authenticator_Authenticate_Call) Return(principal domain.Principal, err error) Authenticator_Authenticate_Call {	106	+	func (_c AuthService_Authenticate_Call) Return(principal domain.Principal, err error) AuthService_Authenticate_Call {
107		_c.Call.Return(principal, err)	107		_c.Call.Return(principal, err)
108		return _c	108		return _c
109		}	109		}
110			110
111	-	func (_c Authenticator_Authenticate_Call) RunAndReturn(run func(ctx context.Context, secret string) (domain.Principal, error)) Authenticator_Authenticate_Call {	111	+	func (_c AuthService_Authenticate_Call) RunAndReturn(run func(ctx context.Context, secret string) (domain.Principal, error)) AuthService_Authenticate_Call {
112		_c.Call.Return(run)	112		_c.Call.Return(run)
113		return _c	113		return _c
114		}	114		}

R internal/adapters/rpc/mocks/Browse.go → internal/ports/mocks/BrowseService.go +81 -81 renamed, 55% similar

 	"context"
 	"io"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 	mock "github.com/stretchr/testify/mock"
 )
-// NewBrowse creates a new instance of Browse. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// NewBrowseService creates a new instance of BrowseService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewBrowse(t interface {
+func NewBrowseService(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *Browse {
+}) *BrowseService {
 	if helper, ok := t.(interface{ Helper() }); ok {
 		helper.Helper()
 	}
-	mock := &Browse{}
+	mock := &BrowseService{}
 	mock.Mock.Test(t)
 	t.Cleanup(func() {
 	return mock
 }
-// Browse is an autogenerated mock type for the Browse type
+// BrowseService is an autogenerated mock type for the BrowseService type
-type Browse struct {
+type BrowseService struct {
 	mock.Mock
 }
-type Browse_Expecter struct {
+type BrowseService_Expecter struct {
 	mock *mock.Mock
 }
-func (_m *Browse) EXPECT() *Browse_Expecter {
+func (_m *BrowseService) EXPECT() *BrowseService_Expecter {
-	return &Browse_Expecter{mock: &_m.Mock}
+	return &BrowseService_Expecter{mock: &_m.Mock}
 }
-// GetCommit provides a mock function for the type Browse
+// GetCommit provides a mock function for the type BrowseService
-func (_mock *Browse) GetCommit(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision) (domain.CommitDetail, error) {
+func (_mock *BrowseService) GetCommit(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision) (domain.CommitDetail, error) {
 	ret := _mock.Called(ctx, p, repo, rev)
 	if len(ret) == 0 {
 	return r0, r1
 }
-// Browse_GetCommit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCommit'
+// BrowseService_GetCommit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCommit'
-type Browse_GetCommit_Call struct {
+type BrowseService_GetCommit_Call struct {
 	*mock.Call
 }
 //   - p domain.Principal
 //   - repo domain.RepoName
 //   - rev domain.Revision
-func (_e *Browse_Expecter) GetCommit(ctx any, p any, repo any, rev any) *Browse_GetCommit_Call {
+func (_e *BrowseService_Expecter) GetCommit(ctx any, p any, repo any, rev any) *BrowseService_GetCommit_Call {
-	return &Browse_GetCommit_Call{Call: _e.mock.On("GetCommit", ctx, p, repo, rev)}
+	return &BrowseService_GetCommit_Call{Call: _e.mock.On("GetCommit", ctx, p, repo, rev)}
 }
-func (_c *Browse_GetCommit_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision)) *Browse_GetCommit_Call {
+func (_c *BrowseService_GetCommit_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision)) *BrowseService_GetCommit_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 	return _c
 }
-func (_c *Browse_GetCommit_Call) Return(commitDetail domain.CommitDetail, err error) *Browse_GetCommit_Call {
+func (_c *BrowseService_GetCommit_Call) Return(commitDetail domain.CommitDetail, err error) *BrowseService_GetCommit_Call {
 	_c.Call.Return(commitDetail, err)
 	return _c
 }
-func (_c *Browse_GetCommit_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision) (domain.CommitDetail, error)) *Browse_GetCommit_Call {
+func (_c *BrowseService_GetCommit_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision) (domain.CommitDetail, error)) *BrowseService_GetCommit_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// GetTree provides a mock function for the type Browse
+// GetTree provides a mock function for the type BrowseService
-func (_mock *Browse) GetTree(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision, path domain.TreePath, includeLastCommit bool) (domain.Tree, error) {
+func (_mock *BrowseService) GetTree(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision, path domain.TreePath, includeLastCommit bool) (domain.Tree, error) {
 	ret := _mock.Called(ctx, p, repo, rev, path, includeLastCommit)
 	if len(ret) == 0 {
 	return r0, r1
 }
-// Browse_GetTree_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTree'
+// BrowseService_GetTree_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTree'
-type Browse_GetTree_Call struct {
+type BrowseService_GetTree_Call struct {
 	*mock.Call
 }
 //   - rev domain.Revision
 //   - path domain.TreePath
 //   - includeLastCommit bool
-func (_e *Browse_Expecter) GetTree(ctx any, p any, repo any, rev any, path any, includeLastCommit any) *Browse_GetTree_Call {
+func (_e *BrowseService_Expecter) GetTree(ctx any, p any, repo any, rev any, path any, includeLastCommit any) *BrowseService_GetTree_Call {
-	return &Browse_GetTree_Call{Call: _e.mock.On("GetTree", ctx, p, repo, rev, path, includeLastCommit)}
+	return &BrowseService_GetTree_Call{Call: _e.mock.On("GetTree", ctx, p, repo, rev, path, includeLastCommit)}
 }
-func (_c *Browse_GetTree_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision, path domain.TreePath, includeLastCommit bool)) *Browse_GetTree_Call {
+func (_c *BrowseService_GetTree_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision, path domain.TreePath, includeLastCommit bool)) *BrowseService_GetTree_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 	return _c
 }
-func (_c *Browse_GetTree_Call) Return(tree domain.Tree, err error) *Browse_GetTree_Call {
+func (_c *BrowseService_GetTree_Call) Return(tree domain.Tree, err error) *BrowseService_GetTree_Call {
 	_c.Call.Return(tree, err)
 	return _c
 }
-func (_c *Browse_GetTree_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision, path domain.TreePath, includeLastCommit bool) (domain.Tree, error)) *Browse_GetTree_Call {
+func (_c *BrowseService_GetTree_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision, path domain.TreePath, includeLastCommit bool) (domain.Tree, error)) *BrowseService_GetTree_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// ListCommits provides a mock function for the type Browse
+// ListCommits provides a mock function for the type BrowseService
-func (_mock *Browse) ListCommits(ctx context.Context, p domain.Principal, repo domain.RepoName, params app.ListCommitsParams) (app.CommitPage, error) {
+func (_mock *BrowseService) ListCommits(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.ListCommitsParams) (ports.HistoryPage, error) {
 	ret := _mock.Called(ctx, p, repo, params)
 	if len(ret) == 0 {
 		panic("no return value specified for ListCommits")
 	}
-	var r0 app.CommitPage
+	var r0 ports.HistoryPage
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, app.ListCommitsParams) (app.CommitPage, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.ListCommitsParams) (ports.HistoryPage, error)); ok {
 		return returnFunc(ctx, p, repo, params)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, app.ListCommitsParams) app.CommitPage); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.ListCommitsParams) ports.HistoryPage); ok {
 		r0 = returnFunc(ctx, p, repo, params)
 	} else {
-		r0 = ret.Get(0).(app.CommitPage)
+		r0 = ret.Get(0).(ports.HistoryPage)
 	}
-	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, app.ListCommitsParams) error); ok {
+	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, ports.ListCommitsParams) error); ok {
 		r1 = returnFunc(ctx, p, repo, params)
 	} else {
 		r1 = ret.Error(1)
 	return r0, r1
 }
-// Browse_ListCommits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCommits'
+// BrowseService_ListCommits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCommits'
-type Browse_ListCommits_Call struct {
+type BrowseService_ListCommits_Call struct {
 	*mock.Call
 }
 //   - ctx context.Context
 //   - p domain.Principal
 //   - repo domain.RepoName
-//   - params app.ListCommitsParams
+//   - params ports.ListCommitsParams
-func (_e *Browse_Expecter) ListCommits(ctx any, p any, repo any, params any) *Browse_ListCommits_Call {
+func (_e *BrowseService_Expecter) ListCommits(ctx any, p any, repo any, params any) *BrowseService_ListCommits_Call {
-	return &Browse_ListCommits_Call{Call: _e.mock.On("ListCommits", ctx, p, repo, params)}
+	return &BrowseService_ListCommits_Call{Call: _e.mock.On("ListCommits", ctx, p, repo, params)}
 }
-func (_c *Browse_ListCommits_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, params app.ListCommitsParams)) *Browse_ListCommits_Call {
+func (_c *BrowseService_ListCommits_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.ListCommitsParams)) *BrowseService_ListCommits_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 		if args[2] != nil {
 			arg2 = args[2].(domain.RepoName)
 		}
-		var arg3 app.ListCommitsParams
+		var arg3 ports.ListCommitsParams
 		if args[3] != nil {
-			arg3 = args[3].(app.ListCommitsParams)
+			arg3 = args[3].(ports.ListCommitsParams)
 		}
 		run(
 			arg0,
 	return _c
 }
-func (_c *Browse_ListCommits_Call) Return(commitPage app.CommitPage, err error) *Browse_ListCommits_Call {
+func (_c *BrowseService_ListCommits_Call) Return(historyPage ports.HistoryPage, err error) *BrowseService_ListCommits_Call {
-	_c.Call.Return(commitPage, err)
+	_c.Call.Return(historyPage, err)
 	return _c
 }
-func (_c *Browse_ListCommits_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, params app.ListCommitsParams) (app.CommitPage, error)) *Browse_ListCommits_Call {
+func (_c *BrowseService_ListCommits_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.ListCommitsParams) (ports.HistoryPage, error)) *BrowseService_ListCommits_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// ListRefs provides a mock function for the type Browse
+// ListRefs provides a mock function for the type BrowseService
-func (_mock *Browse) ListRefs(ctx context.Context, p domain.Principal, repo domain.RepoName, params app.ListRefsParams) (app.RefPage, error) {
+func (_mock *BrowseService) ListRefs(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.ListRefsParams) (ports.RefPage, error) {
 	ret := _mock.Called(ctx, p, repo, params)
 	if len(ret) == 0 {
 		panic("no return value specified for ListRefs")
 	}
-	var r0 app.RefPage
+	var r0 ports.RefPage
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, app.ListRefsParams) (app.RefPage, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.ListRefsParams) (ports.RefPage, error)); ok {
 		return returnFunc(ctx, p, repo, params)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, app.ListRefsParams) app.RefPage); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.ListRefsParams) ports.RefPage); ok {
 		r0 = returnFunc(ctx, p, repo, params)
 	} else {
-		r0 = ret.Get(0).(app.RefPage)
+		r0 = ret.Get(0).(ports.RefPage)
 	}
-	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, app.ListRefsParams) error); ok {
+	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, ports.ListRefsParams) error); ok {
 		r1 = returnFunc(ctx, p, repo, params)
 	} else {
 		r1 = ret.Error(1)
 	return r0, r1
 }
-// Browse_ListRefs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRefs'
+// BrowseService_ListRefs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListRefs'
-type Browse_ListRefs_Call struct {
+type BrowseService_ListRefs_Call struct {
 	*mock.Call
 }
 //   - ctx context.Context
 //   - p domain.Principal
 //   - repo domain.RepoName
-//   - params app.ListRefsParams
+//   - params ports.ListRefsParams
-func (_e *Browse_Expecter) ListRefs(ctx any, p any, repo any, params any) *Browse_ListRefs_Call {
+func (_e *BrowseService_Expecter) ListRefs(ctx any, p any, repo any, params any) *BrowseService_ListRefs_Call {
-	return &Browse_ListRefs_Call{Call: _e.mock.On("ListRefs", ctx, p, repo, params)}
+	return &BrowseService_ListRefs_Call{Call: _e.mock.On("ListRefs", ctx, p, repo, params)}
 }
-func (_c *Browse_ListRefs_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, params app.ListRefsParams)) *Browse_ListRefs_Call {
+func (_c *BrowseService_ListRefs_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.ListRefsParams)) *BrowseService_ListRefs_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 		if args[2] != nil {
 			arg2 = args[2].(domain.RepoName)
 		}
-		var arg3 app.ListRefsParams
+		var arg3 ports.ListRefsParams
 		if args[3] != nil {
-			arg3 = args[3].(app.ListRefsParams)
+			arg3 = args[3].(ports.ListRefsParams)
 		}
 		run(
 			arg0,
 	return _c
 }
-func (_c *Browse_ListRefs_Call) Return(refPage app.RefPage, err error) *Browse_ListRefs_Call {
+func (_c *BrowseService_ListRefs_Call) Return(refPage ports.RefPage, err error) *BrowseService_ListRefs_Call {
 	_c.Call.Return(refPage, err)
 	return _c
 }
-func (_c *Browse_ListRefs_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, params app.ListRefsParams) (app.RefPage, error)) *Browse_ListRefs_Call {
+func (_c *BrowseService_ListRefs_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, params ports.ListRefsParams) (ports.RefPage, error)) *BrowseService_ListRefs_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// OpenBlob provides a mock function for the type Browse
+// OpenBlob provides a mock function for the type BrowseService
-func (_mock *Browse) OpenBlob(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision, path domain.TreePath) (domain.BlobInfo, io.ReadCloser, error) {
+func (_mock *BrowseService) OpenBlob(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision, path domain.TreePath) (domain.BlobInfo, io.ReadCloser, error) {
 	ret := _mock.Called(ctx, p, repo, rev, path)
 	if len(ret) == 0 {
 	return r0, r1, r2
 }
-// Browse_OpenBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenBlob'
+// BrowseService_OpenBlob_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OpenBlob'
-type Browse_OpenBlob_Call struct {
+type BrowseService_OpenBlob_Call struct {
 	*mock.Call
 }
 //   - repo domain.RepoName
 //   - rev domain.Revision
 //   - path domain.TreePath
-func (_e *Browse_Expecter) OpenBlob(ctx any, p any, repo any, rev any, path any) *Browse_OpenBlob_Call {
+func (_e *BrowseService_Expecter) OpenBlob(ctx any, p any, repo any, rev any, path any) *BrowseService_OpenBlob_Call {
-	return &Browse_OpenBlob_Call{Call: _e.mock.On("OpenBlob", ctx, p, repo, rev, path)}
+	return &BrowseService_OpenBlob_Call{Call: _e.mock.On("OpenBlob", ctx, p, repo, rev, path)}
 }
-func (_c *Browse_OpenBlob_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision, path domain.TreePath)) *Browse_OpenBlob_Call {
+func (_c *BrowseService_OpenBlob_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision, path domain.TreePath)) *BrowseService_OpenBlob_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 	return _c
 }
-func (_c *Browse_OpenBlob_Call) Return(blobInfo domain.BlobInfo, readCloser io.ReadCloser, err error) *Browse_OpenBlob_Call {
+func (_c *BrowseService_OpenBlob_Call) Return(blobInfo domain.BlobInfo, readCloser io.ReadCloser, err error) *BrowseService_OpenBlob_Call {
 	_c.Call.Return(blobInfo, readCloser, err)
 	return _c
 }
-func (_c *Browse_OpenBlob_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision, path domain.TreePath) (domain.BlobInfo, io.ReadCloser, error)) *Browse_OpenBlob_Call {
+func (_c *BrowseService_OpenBlob_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision, path domain.TreePath) (domain.BlobInfo, io.ReadCloser, error)) *BrowseService_OpenBlob_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// ResolveRevision provides a mock function for the type Browse
+// ResolveRevision provides a mock function for the type BrowseService
-func (_mock *Browse) ResolveRevision(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision) (domain.ResolvedRevision, error) {
+func (_mock *BrowseService) ResolveRevision(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision) (domain.ResolvedRevision, error) {
 	ret := _mock.Called(ctx, p, repo, rev)
 	if len(ret) == 0 {
 	return r0, r1
 }
-// Browse_ResolveRevision_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResolveRevision'
+// BrowseService_ResolveRevision_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResolveRevision'
-type Browse_ResolveRevision_Call struct {
+type BrowseService_ResolveRevision_Call struct {
 	*mock.Call
 }
 //   - p domain.Principal
 //   - repo domain.RepoName
 //   - rev domain.Revision
-func (_e *Browse_Expecter) ResolveRevision(ctx any, p any, repo any, rev any) *Browse_ResolveRevision_Call {
+func (_e *BrowseService_Expecter) ResolveRevision(ctx any, p any, repo any, rev any) *BrowseService_ResolveRevision_Call {
-	return &Browse_ResolveRevision_Call{Call: _e.mock.On("ResolveRevision", ctx, p, repo, rev)}
+	return &BrowseService_ResolveRevision_Call{Call: _e.mock.On("ResolveRevision", ctx, p, repo, rev)}
 }
-func (_c *Browse_ResolveRevision_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision)) *Browse_ResolveRevision_Call {
+func (_c *BrowseService_ResolveRevision_Call) Run(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision)) *BrowseService_ResolveRevision_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 	return _c
 }
-func (_c *Browse_ResolveRevision_Call) Return(resolvedRevision domain.ResolvedRevision, err error) *Browse_ResolveRevision_Call {
+func (_c *BrowseService_ResolveRevision_Call) Return(resolvedRevision domain.ResolvedRevision, err error) *BrowseService_ResolveRevision_Call {
 	_c.Call.Return(resolvedRevision, err)
 	return _c
 }
-func (_c *Browse_ResolveRevision_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision) (domain.ResolvedRevision, error)) *Browse_ResolveRevision_Call {
+func (_c *BrowseService_ResolveRevision_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision) (domain.ResolvedRevision, error)) *BrowseService_ResolveRevision_Call {
 	_c.Call.Return(run)
 	return _c
 }

A internal/ports/mocks/EventService.go +118 -0

@@ -0,0 +1,118 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"context"
	9	+
	10	+	"bnema.dev/ermite/internal/domain"
	11	+	"bnema.dev/ermite/internal/ports"
	12	+	mock "github.com/stretchr/testify/mock"
	13	+	)
	14	+
	15	+	// NewEventService creates a new instance of EventService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	16	+	// The first argument is typically a *testing.T value.
	17	+	func NewEventService(t interface {
	18	+	mock.TestingT
	19	+	Cleanup(func())
	20	+	}) *EventService {
	21	+	if helper, ok := t.(interface{ Helper() }); ok {
	22	+	helper.Helper()
	23	+	}
	24	+
	25	+	mock := &EventService{}
	26	+	mock.Mock.Test(t)
	27	+
	28	+	t.Cleanup(func() {
	29	+	if helper, ok := t.(interface{ Helper() }); ok {
	30	+	helper.Helper()
	31	+	}
	32	+	mock.AssertExpectations(t)
	33	+	})
	34	+
	35	+	return mock
	36	+	}
	37	+
	38	+	// EventService is an autogenerated mock type for the EventService type
	39	+	type EventService struct {
	40	+	mock.Mock
	41	+	}
	42	+
	43	+	type EventService_Expecter struct {
	44	+	mock *mock.Mock
	45	+	}
	46	+
	47	+	func (_m EventService) EXPECT() EventService_Expecter {
	48	+	return &EventService_Expecter{mock: &_m.Mock}
	49	+	}
	50	+
	51	+	// Watch provides a mock function for the type EventService
	52	+	func (_mock *EventService) Watch(ctx context.Context, p domain.Principal, params ports.WatchParams, send func(ports.WatchEvent) error) error {
	53	+	ret := _mock.Called(ctx, p, params, send)
	54	+
	55	+	if len(ret) == 0 {
	56	+	panic("no return value specified for Watch")
	57	+	}
	58	+
	59	+	var r0 error
	60	+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, ports.WatchParams, func(ports.WatchEvent) error) error); ok {
	61	+	r0 = returnFunc(ctx, p, params, send)
	62	+	} else {
	63	+	r0 = ret.Error(0)
	64	+	}
	65	+	return r0
	66	+	}
	67	+
	68	+	// EventService_Watch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Watch'
	69	+	type EventService_Watch_Call struct {
	70	+	*mock.Call
	71	+	}
	72	+
	73	+	// Watch is a helper method to define mock.On call
	74	+	// - ctx context.Context
	75	+	// - p domain.Principal
	76	+	// - params ports.WatchParams
	77	+	// - send func(ports.WatchEvent) error
	78	+	func (_e EventService_Expecter) Watch(ctx any, p any, params any, send any) EventService_Watch_Call {
	79	+	return &EventService_Watch_Call{Call: _e.mock.On("Watch", ctx, p, params, send)}
	80	+	}
	81	+
	82	+	func (_c EventService_Watch_Call) Run(run func(ctx context.Context, p domain.Principal, params ports.WatchParams, send func(ports.WatchEvent) error)) EventService_Watch_Call {
	83	+	_c.Call.Run(func(args mock.Arguments) {
	84	+	var arg0 context.Context
	85	+	if args[0] != nil {
	86	+	arg0 = args[0].(context.Context)
	87	+	}
	88	+	var arg1 domain.Principal
	89	+	if args[1] != nil {
	90	+	arg1 = args[1].(domain.Principal)
	91	+	}
	92	+	var arg2 ports.WatchParams
	93	+	if args[2] != nil {
	94	+	arg2 = args[2].(ports.WatchParams)
	95	+	}
	96	+	var arg3 func(ports.WatchEvent) error
	97	+	if args[3] != nil {
	98	+	arg3 = args[3].(func(ports.WatchEvent) error)
	99	+	}
	100	+	run(
	101	+	arg0,
	102	+	arg1,
	103	+	arg2,
	104	+	arg3,
	105	+	)
	106	+	})
	107	+	return _c
	108	+	}
	109	+
	110	+	func (_c EventService_Watch_Call) Return(err error) EventService_Watch_Call {
	111	+	_c.Call.Return(err)
	112	+	return _c
	113	+	}
	114	+
	115	+	func (_c EventService_Watch_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, params ports.WatchParams, send func(ports.WatchEvent) error) error) EventService_Watch_Call {
	116	+	_c.Call.Return(run)
	117	+	return _c
	118	+	}

R internal/adapters/githttp/mocks/FailureLimiter.go → internal/ports/mocks/FailureLimiter.go +0 -0 renamed, 100% similar

renamed, 100% similar

R internal/adapters/githttp/mocks/HookTokens.go → internal/ports/mocks/HookTokens.go +0 -0 renamed, 100% similar

renamed, 100% similar

R internal/app/mocks/MaintenanceScheduler.go → internal/ports/mocks/MaintenanceScheduler.go +0 -0 renamed, 100% similar

renamed, 100% similar

R internal/adapters/rpc/mocks/MergeRequests.go → internal/ports/mocks/MergeRequestService.go +114 -114 renamed, 50% similar

 import (
 	"context"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 	mock "github.com/stretchr/testify/mock"
 )
-// NewMergeRequests creates a new instance of MergeRequests. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// NewMergeRequestService creates a new instance of MergeRequestService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewMergeRequests(t interface {
+func NewMergeRequestService(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *MergeRequests {
+}) *MergeRequestService {
 	if helper, ok := t.(interface{ Helper() }); ok {
 		helper.Helper()
 	}
-	mock := &MergeRequests{}
+	mock := &MergeRequestService{}
 	mock.Mock.Test(t)
 	t.Cleanup(func() {
 	return mock
 }
-// MergeRequests is an autogenerated mock type for the MergeRequests type
+// MergeRequestService is an autogenerated mock type for the MergeRequestService type
-type MergeRequests struct {
+type MergeRequestService struct {
 	mock.Mock
 }
-type MergeRequests_Expecter struct {
+type MergeRequestService_Expecter struct {
 	mock *mock.Mock
 }
-func (_m *MergeRequests) EXPECT() *MergeRequests_Expecter {
+func (_m *MergeRequestService) EXPECT() *MergeRequestService_Expecter {
-	return &MergeRequests_Expecter{mock: &_m.Mock}
+	return &MergeRequestService_Expecter{mock: &_m.Mock}
 }
-// AddComment provides a mock function for the type MergeRequests
+// AddComment provides a mock function for the type MergeRequestService
-func (_mock *MergeRequests) AddComment(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params app.AddCommentParams) (domain.Comment, error) {
+func (_mock *MergeRequestService) AddComment(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.AddCommentParams) (domain.Comment, error) {
 	ret := _mock.Called(ctx, p, name, number, params)
 	if len(ret) == 0 {
 	var r0 domain.Comment
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, app.AddCommentParams) (domain.Comment, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.AddCommentParams) (domain.Comment, error)); ok {
 		return returnFunc(ctx, p, name, number, params)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, app.AddCommentParams) domain.Comment); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.AddCommentParams) domain.Comment); ok {
 		r0 = returnFunc(ctx, p, name, number, params)
 	} else {
 		r0 = ret.Get(0).(domain.Comment)
 	}
-	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64, app.AddCommentParams) error); ok {
+	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.AddCommentParams) error); ok {
 		r1 = returnFunc(ctx, p, name, number, params)
 	} else {
 		r1 = ret.Error(1)
 	return r0, r1
 }
-// MergeRequests_AddComment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddComment'
+// MergeRequestService_AddComment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddComment'
-type MergeRequests_AddComment_Call struct {
+type MergeRequestService_AddComment_Call struct {
 	*mock.Call
 }
 //   - p domain.Principal
 //   - name domain.RepoName
 //   - number int64
-//   - params app.AddCommentParams
+//   - params ports.AddCommentParams
-func (_e *MergeRequests_Expecter) AddComment(ctx any, p any, name any, number any, params any) *MergeRequests_AddComment_Call {
+func (_e *MergeRequestService_Expecter) AddComment(ctx any, p any, name any, number any, params any) *MergeRequestService_AddComment_Call {
-	return &MergeRequests_AddComment_Call{Call: _e.mock.On("AddComment", ctx, p, name, number, params)}
+	return &MergeRequestService_AddComment_Call{Call: _e.mock.On("AddComment", ctx, p, name, number, params)}
 }
-func (_c *MergeRequests_AddComment_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params app.AddCommentParams)) *MergeRequests_AddComment_Call {
+func (_c *MergeRequestService_AddComment_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.AddCommentParams)) *MergeRequestService_AddComment_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 		if args[3] != nil {
 			arg3 = args[3].(int64)
 		}
-		var arg4 app.AddCommentParams
+		var arg4 ports.AddCommentParams
 		if args[4] != nil {
-			arg4 = args[4].(app.AddCommentParams)
+			arg4 = args[4].(ports.AddCommentParams)
 		}
 		run(
 			arg0,
 	return _c
 }
-func (_c *MergeRequests_AddComment_Call) Return(comment domain.Comment, err error) *MergeRequests_AddComment_Call {
+func (_c *MergeRequestService_AddComment_Call) Return(comment domain.Comment, err error) *MergeRequestService_AddComment_Call {
 	_c.Call.Return(comment, err)
 	return _c
 }
-func (_c *MergeRequests_AddComment_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params app.AddCommentParams) (domain.Comment, error)) *MergeRequests_AddComment_Call {
+func (_c *MergeRequestService_AddComment_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.AddCommentParams) (domain.Comment, error)) *MergeRequestService_AddComment_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// Close provides a mock function for the type MergeRequests
+// Close provides a mock function for the type MergeRequestService
-func (_mock *MergeRequests) Close(ctx context.Context, p domain.Principal, name domain.RepoName, number int64) (domain.MergeRequest, error) {
+func (_mock *MergeRequestService) Close(ctx context.Context, p domain.Principal, name domain.RepoName, number int64) (domain.MergeRequest, error) {
 	ret := _mock.Called(ctx, p, name, number)
 	if len(ret) == 0 {
 	return r0, r1
 }
-// MergeRequests_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
+// MergeRequestService_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
-type MergeRequests_Close_Call struct {
+type MergeRequestService_Close_Call struct {
 	*mock.Call
 }
 //   - p domain.Principal
 //   - name domain.RepoName
 //   - number int64
-func (_e *MergeRequests_Expecter) Close(ctx any, p any, name any, number any) *MergeRequests_Close_Call {
+func (_e *MergeRequestService_Expecter) Close(ctx any, p any, name any, number any) *MergeRequestService_Close_Call {
-	return &MergeRequests_Close_Call{Call: _e.mock.On("Close", ctx, p, name, number)}
+	return &MergeRequestService_Close_Call{Call: _e.mock.On("Close", ctx, p, name, number)}
 }
-func (_c *MergeRequests_Close_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64)) *MergeRequests_Close_Call {
+func (_c *MergeRequestService_Close_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64)) *MergeRequestService_Close_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 	return _c
 }
-func (_c *MergeRequests_Close_Call) Return(mergeRequest domain.MergeRequest, err error) *MergeRequests_Close_Call {
+func (_c *MergeRequestService_Close_Call) Return(mergeRequest domain.MergeRequest, err error) *MergeRequestService_Close_Call {
 	_c.Call.Return(mergeRequest, err)
 	return _c
 }
-func (_c *MergeRequests_Close_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64) (domain.MergeRequest, error)) *MergeRequests_Close_Call {
+func (_c *MergeRequestService_Close_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64) (domain.MergeRequest, error)) *MergeRequestService_Close_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// Create provides a mock function for the type MergeRequests
+// Create provides a mock function for the type MergeRequestService
-func (_mock *MergeRequests) Create(ctx context.Context, p domain.Principal, name domain.RepoName, params app.CreateMergeRequestParams) (domain.MergeRequest, error) {
+func (_mock *MergeRequestService) Create(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.CreateMergeRequestParams) (domain.MergeRequest, error) {
 	ret := _mock.Called(ctx, p, name, params)
 	if len(ret) == 0 {
 	var r0 domain.MergeRequest
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, app.CreateMergeRequestParams) (domain.MergeRequest, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.CreateMergeRequestParams) (domain.MergeRequest, error)); ok {
 		return returnFunc(ctx, p, name, params)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, app.CreateMergeRequestParams) domain.MergeRequest); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.CreateMergeRequestParams) domain.MergeRequest); ok {
 		r0 = returnFunc(ctx, p, name, params)
 	} else {
 		r0 = ret.Get(0).(domain.MergeRequest)
 	}
-	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, app.CreateMergeRequestParams) error); ok {
+	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, ports.CreateMergeRequestParams) error); ok {
 		r1 = returnFunc(ctx, p, name, params)
 	} else {
 		r1 = ret.Error(1)
 	return r0, r1
 }
-// MergeRequests_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
+// MergeRequestService_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
-type MergeRequests_Create_Call struct {
+type MergeRequestService_Create_Call struct {
 	*mock.Call
 }
 //   - ctx context.Context
 //   - p domain.Principal
 //   - name domain.RepoName
-//   - params app.CreateMergeRequestParams
+//   - params ports.CreateMergeRequestParams
-func (_e *MergeRequests_Expecter) Create(ctx any, p any, name any, params any) *MergeRequests_Create_Call {
+func (_e *MergeRequestService_Expecter) Create(ctx any, p any, name any, params any) *MergeRequestService_Create_Call {
-	return &MergeRequests_Create_Call{Call: _e.mock.On("Create", ctx, p, name, params)}
+	return &MergeRequestService_Create_Call{Call: _e.mock.On("Create", ctx, p, name, params)}
 }
-func (_c *MergeRequests_Create_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, params app.CreateMergeRequestParams)) *MergeRequests_Create_Call {
+func (_c *MergeRequestService_Create_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.CreateMergeRequestParams)) *MergeRequestService_Create_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 		if args[2] != nil {
 			arg2 = args[2].(domain.RepoName)
 		}
-		var arg3 app.CreateMergeRequestParams
+		var arg3 ports.CreateMergeRequestParams
 		if args[3] != nil {
-			arg3 = args[3].(app.CreateMergeRequestParams)
+			arg3 = args[3].(ports.CreateMergeRequestParams)
 		}
 		run(
 			arg0,
 	return _c
 }
-func (_c *MergeRequests_Create_Call) Return(mergeRequest domain.MergeRequest, err error) *MergeRequests_Create_Call {
+func (_c *MergeRequestService_Create_Call) Return(mergeRequest domain.MergeRequest, err error) *MergeRequestService_Create_Call {
 	_c.Call.Return(mergeRequest, err)
 	return _c
 }
-func (_c *MergeRequests_Create_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, params app.CreateMergeRequestParams) (domain.MergeRequest, error)) *MergeRequests_Create_Call {
+func (_c *MergeRequestService_Create_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.CreateMergeRequestParams) (domain.MergeRequest, error)) *MergeRequestService_Create_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// Get provides a mock function for the type MergeRequests
+// Get provides a mock function for the type MergeRequestService
-func (_mock *MergeRequests) Get(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, sinceLastRead bool) (app.MergeRequestDetail, error) {
+func (_mock *MergeRequestService) Get(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, sinceLastRead bool) (ports.MergeRequestDetail, error) {
 	ret := _mock.Called(ctx, p, name, number, sinceLastRead)
 	if len(ret) == 0 {
 		panic("no return value specified for Get")
 	}
-	var r0 app.MergeRequestDetail
+	var r0 ports.MergeRequestDetail
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, bool) (app.MergeRequestDetail, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, bool) (ports.MergeRequestDetail, error)); ok {
 		return returnFunc(ctx, p, name, number, sinceLastRead)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, bool) app.MergeRequestDetail); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, bool) ports.MergeRequestDetail); ok {
 		r0 = returnFunc(ctx, p, name, number, sinceLastRead)
 	} else {
-		r0 = ret.Get(0).(app.MergeRequestDetail)
+		r0 = ret.Get(0).(ports.MergeRequestDetail)
 	}
 	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64, bool) error); ok {
 		r1 = returnFunc(ctx, p, name, number, sinceLastRead)
 	return r0, r1
 }
-// MergeRequests_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
+// MergeRequestService_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
-type MergeRequests_Get_Call struct {
+type MergeRequestService_Get_Call struct {
 	*mock.Call
 }
 //   - name domain.RepoName
 //   - number int64
 //   - sinceLastRead bool
-func (_e *MergeRequests_Expecter) Get(ctx any, p any, name any, number any, sinceLastRead any) *MergeRequests_Get_Call {
+func (_e *MergeRequestService_Expecter) Get(ctx any, p any, name any, number any, sinceLastRead any) *MergeRequestService_Get_Call {
-	return &MergeRequests_Get_Call{Call: _e.mock.On("Get", ctx, p, name, number, sinceLastRead)}
+	return &MergeRequestService_Get_Call{Call: _e.mock.On("Get", ctx, p, name, number, sinceLastRead)}
 }
-func (_c *MergeRequests_Get_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, sinceLastRead bool)) *MergeRequests_Get_Call {
+func (_c *MergeRequestService_Get_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, sinceLastRead bool)) *MergeRequestService_Get_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 	return _c
 }
-func (_c *MergeRequests_Get_Call) Return(mergeRequestDetail app.MergeRequestDetail, err error) *MergeRequests_Get_Call {
+func (_c *MergeRequestService_Get_Call) Return(mergeRequestDetail ports.MergeRequestDetail, err error) *MergeRequestService_Get_Call {
 	_c.Call.Return(mergeRequestDetail, err)
 	return _c
 }
-func (_c *MergeRequests_Get_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, sinceLastRead bool) (app.MergeRequestDetail, error)) *MergeRequests_Get_Call {
+func (_c *MergeRequestService_Get_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, sinceLastRead bool) (ports.MergeRequestDetail, error)) *MergeRequestService_Get_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// List provides a mock function for the type MergeRequests
+// List provides a mock function for the type MergeRequestService
-func (_mock *MergeRequests) List(ctx context.Context, p domain.Principal, name domain.RepoName, params app.ListMergeRequestsParams) (app.MergeRequestPage, error) {
+func (_mock *MergeRequestService) List(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.ListMergeRequestsParams) (ports.MergeRequestPage, error) {
 	ret := _mock.Called(ctx, p, name, params)
 	if len(ret) == 0 {
 		panic("no return value specified for List")
 	}
-	var r0 app.MergeRequestPage
+	var r0 ports.MergeRequestPage
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, app.ListMergeRequestsParams) (app.MergeRequestPage, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.ListMergeRequestsParams) (ports.MergeRequestPage, error)); ok {
 		return returnFunc(ctx, p, name, params)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, app.ListMergeRequestsParams) app.MergeRequestPage); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.ListMergeRequestsParams) ports.MergeRequestPage); ok {
 		r0 = returnFunc(ctx, p, name, params)
 	} else {
-		r0 = ret.Get(0).(app.MergeRequestPage)
+		r0 = ret.Get(0).(ports.MergeRequestPage)
 	}
-	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, app.ListMergeRequestsParams) error); ok {
+	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, ports.ListMergeRequestsParams) error); ok {
 		r1 = returnFunc(ctx, p, name, params)
 	} else {
 		r1 = ret.Error(1)
 	return r0, r1
 }
-// MergeRequests_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'
+// MergeRequestService_List_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'List'
-type MergeRequests_List_Call struct {
+type MergeRequestService_List_Call struct {
 	*mock.Call
 }
 //   - ctx context.Context
 //   - p domain.Principal
 //   - name domain.RepoName
-//   - params app.ListMergeRequestsParams
+//   - params ports.ListMergeRequestsParams
-func (_e *MergeRequests_Expecter) List(ctx any, p any, name any, params any) *MergeRequests_List_Call {
+func (_e *MergeRequestService_Expecter) List(ctx any, p any, name any, params any) *MergeRequestService_List_Call {
-	return &MergeRequests_List_Call{Call: _e.mock.On("List", ctx, p, name, params)}
+	return &MergeRequestService_List_Call{Call: _e.mock.On("List", ctx, p, name, params)}
 }
-func (_c *MergeRequests_List_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, params app.ListMergeRequestsParams)) *MergeRequests_List_Call {
+func (_c *MergeRequestService_List_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.ListMergeRequestsParams)) *MergeRequestService_List_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 		if args[2] != nil {
 			arg2 = args[2].(domain.RepoName)
 		}
-		var arg3 app.ListMergeRequestsParams
+		var arg3 ports.ListMergeRequestsParams
 		if args[3] != nil {
-			arg3 = args[3].(app.ListMergeRequestsParams)
+			arg3 = args[3].(ports.ListMergeRequestsParams)
 		}
 		run(
 			arg0,
 	return _c
 }
-func (_c *MergeRequests_List_Call) Return(mergeRequestPage app.MergeRequestPage, err error) *MergeRequests_List_Call {
+func (_c *MergeRequestService_List_Call) Return(mergeRequestPage ports.MergeRequestPage, err error) *MergeRequestService_List_Call {
 	_c.Call.Return(mergeRequestPage, err)
 	return _c
 }
-func (_c *MergeRequests_List_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, params app.ListMergeRequestsParams) (app.MergeRequestPage, error)) *MergeRequests_List_Call {
+func (_c *MergeRequestService_List_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.ListMergeRequestsParams) (ports.MergeRequestPage, error)) *MergeRequestService_List_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// MarkRead provides a mock function for the type MergeRequests
+// MarkRead provides a mock function for the type MergeRequestService
-func (_mock *MergeRequests) MarkRead(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, head domain.ObjectID) (domain.ObjectID, error) {
+func (_mock *MergeRequestService) MarkRead(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, head domain.ObjectID) (domain.ObjectID, error) {
 	ret := _mock.Called(ctx, p, name, number, head)
 	if len(ret) == 0 {
 	return r0, r1
 }
-// MergeRequests_MarkRead_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarkRead'
+// MergeRequestService_MarkRead_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarkRead'
-type MergeRequests_MarkRead_Call struct {
+type MergeRequestService_MarkRead_Call struct {
 	*mock.Call
 }
 //   - name domain.RepoName
 //   - number int64
 //   - head domain.ObjectID
-func (_e *MergeRequests_Expecter) MarkRead(ctx any, p any, name any, number any, head any) *MergeRequests_MarkRead_Call {
+func (_e *MergeRequestService_Expecter) MarkRead(ctx any, p any, name any, number any, head any) *MergeRequestService_MarkRead_Call {
-	return &MergeRequests_MarkRead_Call{Call: _e.mock.On("MarkRead", ctx, p, name, number, head)}
+	return &MergeRequestService_MarkRead_Call{Call: _e.mock.On("MarkRead", ctx, p, name, number, head)}
 }
-func (_c *MergeRequests_MarkRead_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, head domain.ObjectID)) *MergeRequests_MarkRead_Call {
+func (_c *MergeRequestService_MarkRead_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, head domain.ObjectID)) *MergeRequestService_MarkRead_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 	return _c
 }
-func (_c *MergeRequests_MarkRead_Call) Return(objectID domain.ObjectID, err error) *MergeRequests_MarkRead_Call {
+func (_c *MergeRequestService_MarkRead_Call) Return(objectID domain.ObjectID, err error) *MergeRequestService_MarkRead_Call {
 	_c.Call.Return(objectID, err)
 	return _c
 }
-func (_c *MergeRequests_MarkRead_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, head domain.ObjectID) (domain.ObjectID, error)) *MergeRequests_MarkRead_Call {
+func (_c *MergeRequestService_MarkRead_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, head domain.ObjectID) (domain.ObjectID, error)) *MergeRequestService_MarkRead_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// Merge provides a mock function for the type MergeRequests
+// Merge provides a mock function for the type MergeRequestService
-func (_mock *MergeRequests) Merge(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params app.MergeParams) (app.MergeResult, error) {
+func (_mock *MergeRequestService) Merge(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.MergeParams) (ports.MergeResult, error) {
 	ret := _mock.Called(ctx, p, name, number, params)
 	if len(ret) == 0 {
 		panic("no return value specified for Merge")
 	}
-	var r0 app.MergeResult
+	var r0 ports.MergeResult
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, app.MergeParams) (app.MergeResult, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.MergeParams) (ports.MergeResult, error)); ok {
 		return returnFunc(ctx, p, name, number, params)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, app.MergeParams) app.MergeResult); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.MergeParams) ports.MergeResult); ok {
 		r0 = returnFunc(ctx, p, name, number, params)
 	} else {
-		r0 = ret.Get(0).(app.MergeResult)
+		r0 = ret.Get(0).(ports.MergeResult)
 	}
-	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64, app.MergeParams) error); ok {
+	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, int64, ports.MergeParams) error); ok {
 		r1 = returnFunc(ctx, p, name, number, params)
 	} else {
 		r1 = ret.Error(1)
 	return r0, r1
 }
-// MergeRequests_Merge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Merge'
+// MergeRequestService_Merge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Merge'
-type MergeRequests_Merge_Call struct {
+type MergeRequestService_Merge_Call struct {
 	*mock.Call
 }
 //   - p domain.Principal
 //   - name domain.RepoName
 //   - number int64
-//   - params app.MergeParams
+//   - params ports.MergeParams
-func (_e *MergeRequests_Expecter) Merge(ctx any, p any, name any, number any, params any) *MergeRequests_Merge_Call {
+func (_e *MergeRequestService_Expecter) Merge(ctx any, p any, name any, number any, params any) *MergeRequestService_Merge_Call {
-	return &MergeRequests_Merge_Call{Call: _e.mock.On("Merge", ctx, p, name, number, params)}
+	return &MergeRequestService_Merge_Call{Call: _e.mock.On("Merge", ctx, p, name, number, params)}
 }
-func (_c *MergeRequests_Merge_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params app.MergeParams)) *MergeRequests_Merge_Call {
+func (_c *MergeRequestService_Merge_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.MergeParams)) *MergeRequestService_Merge_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 		if args[3] != nil {
 			arg3 = args[3].(int64)
 		}
-		var arg4 app.MergeParams
+		var arg4 ports.MergeParams
 		if args[4] != nil {
-			arg4 = args[4].(app.MergeParams)
+			arg4 = args[4].(ports.MergeParams)
 		}
 		run(
 			arg0,
 	return _c
 }
-func (_c *MergeRequests_Merge_Call) Return(mergeResult app.MergeResult, err error) *MergeRequests_Merge_Call {
+func (_c *MergeRequestService_Merge_Call) Return(mergeResult ports.MergeResult, err error) *MergeRequestService_Merge_Call {
 	_c.Call.Return(mergeResult, err)
 	return _c
 }
-func (_c *MergeRequests_Merge_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params app.MergeParams) (app.MergeResult, error)) *MergeRequests_Merge_Call {
+func (_c *MergeRequestService_Merge_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params ports.MergeParams) (ports.MergeResult, error)) *MergeRequestService_Merge_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// ResolveComment provides a mock function for the type MergeRequests
+// ResolveComment provides a mock function for the type MergeRequestService
-func (_mock *MergeRequests) ResolveComment(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, commentID int64, resolved bool) (domain.Comment, error) {
+func (_mock *MergeRequestService) ResolveComment(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, commentID int64, resolved bool) (domain.Comment, error) {
 	ret := _mock.Called(ctx, p, name, number, commentID, resolved)
 	if len(ret) == 0 {
 	return r0, r1
 }
-// MergeRequests_ResolveComment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResolveComment'
+// MergeRequestService_ResolveComment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResolveComment'
-type MergeRequests_ResolveComment_Call struct {
+type MergeRequestService_ResolveComment_Call struct {
 	*mock.Call
 }
 //   - number int64
 //   - commentID int64
 //   - resolved bool
-func (_e *MergeRequests_Expecter) ResolveComment(ctx any, p any, name any, number any, commentID any, resolved any) *MergeRequests_ResolveComment_Call {
+func (_e *MergeRequestService_Expecter) ResolveComment(ctx any, p any, name any, number any, commentID any, resolved any) *MergeRequestService_ResolveComment_Call {
-	return &MergeRequests_ResolveComment_Call{Call: _e.mock.On("ResolveComment", ctx, p, name, number, commentID, resolved)}
+	return &MergeRequestService_ResolveComment_Call{Call: _e.mock.On("ResolveComment", ctx, p, name, number, commentID, resolved)}
 }
-func (_c *MergeRequests_ResolveComment_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, commentID int64, resolved bool)) *MergeRequests_ResolveComment_Call {
+func (_c *MergeRequestService_ResolveComment_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, commentID int64, resolved bool)) *MergeRequestService_ResolveComment_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 	return _c
 }
-func (_c *MergeRequests_ResolveComment_Call) Return(comment domain.Comment, err error) *MergeRequests_ResolveComment_Call {
+func (_c *MergeRequestService_ResolveComment_Call) Return(comment domain.Comment, err error) *MergeRequestService_ResolveComment_Call {
 	_c.Call.Return(comment, err)
 	return _c
 }
-func (_c *MergeRequests_ResolveComment_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, commentID int64, resolved bool) (domain.Comment, error)) *MergeRequests_ResolveComment_Call {
+func (_c *MergeRequestService_ResolveComment_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, commentID int64, resolved bool) (domain.Comment, error)) *MergeRequestService_ResolveComment_Call {
 	_c.Call.Return(run)
 	return _c
 }

R internal/adapters/githttp/mocks/PushHooks.go → internal/ports/mocks/PushHookService.go +27 -27 renamed, 51% similar


@@ -11,17 +11,17 @@ import (
11		mock "github.com/stretchr/testify/mock"	11		mock "github.com/stretchr/testify/mock"
12		)	12		)
13			13
14	-	// NewPushHooks creates a new instance of PushHooks. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.	14	+	// NewPushHookService creates a new instance of PushHookService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15		// The first argument is typically a *testing.T value.	15		// The first argument is typically a *testing.T value.
16	-	func NewPushHooks(t interface {	16	+	func NewPushHookService(t interface {
17		mock.TestingT	17		mock.TestingT
18		Cleanup(func())	18		Cleanup(func())
19	-	}) *PushHooks {	19	+	}) *PushHookService {
20		if helper, ok := t.(interface{ Helper() }); ok {	20		if helper, ok := t.(interface{ Helper() }); ok {
21		helper.Helper()	21		helper.Helper()
22		}	22		}
23			23
24	-	mock := &PushHooks{}	24	+	mock := &PushHookService{}
25		mock.Mock.Test(t)	25		mock.Mock.Test(t)
26			26
27		t.Cleanup(func() {	27		t.Cleanup(func() {

@@ -34,21 +34,21 @@ func NewPushHooks(t interface {
34		return mock	34		return mock
35		}	35		}
36			36
37	-	// PushHooks is an autogenerated mock type for the PushHooks type	37	+	// PushHookService is an autogenerated mock type for the PushHookService type
38	-	type PushHooks struct {	38	+	type PushHookService struct {
39		mock.Mock	39		mock.Mock
40		}	40		}
41			41
42	-	type PushHooks_Expecter struct {	42	+	type PushHookService_Expecter struct {
43		mock *mock.Mock	43		mock *mock.Mock
44		}	44		}
45			45
46	-	func (_m PushHooks) EXPECT() PushHooks_Expecter {	46	+	func (_m PushHookService) EXPECT() PushHookService_Expecter {
47	-	return &PushHooks_Expecter{mock: &_m.Mock}	47	+	return &PushHookService_Expecter{mock: &_m.Mock}
48		}	48		}
49			49
50	-	// Check provides a mock function for the type PushHooks	50	+	// Check provides a mock function for the type PushHookService
51	-	func (_mock *PushHooks) Check(ctx context.Context, p domain.Principal, name domain.RepoName, updates []domain.RefUpdate) error {	51	+	func (_mock *PushHookService) Check(ctx context.Context, p domain.Principal, name domain.RepoName, updates []domain.RefUpdate) error {
52		ret := _mock.Called(ctx, p, name, updates)	52		ret := _mock.Called(ctx, p, name, updates)
53			53
54		if len(ret) == 0 {	54		if len(ret) == 0 {

@@ -64,8 +64,8 @@ func (_mock *PushHooks) Check(ctx context.Context, p domain.Principal, name doma
64		return r0	64		return r0
65		}	65		}
66			66
67	-	// PushHooks_Check_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Check'	67	+	// PushHookService_Check_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Check'
68	-	type PushHooks_Check_Call struct {	68	+	type PushHookService_Check_Call struct {
69		*mock.Call	69		*mock.Call
70		}	70		}
71			71

@@ -74,11 +74,11 @@ type PushHooks_Check_Call struct {
74		// - p domain.Principal	74		// - p domain.Principal
75		// - name domain.RepoName	75		// - name domain.RepoName
76		// - updates []domain.RefUpdate	76		// - updates []domain.RefUpdate
77	-	func (_e PushHooks_Expecter) Check(ctx any, p any, name any, updates any) PushHooks_Check_Call {	77	+	func (_e PushHookService_Expecter) Check(ctx any, p any, name any, updates any) PushHookService_Check_Call {
78	-	return &PushHooks_Check_Call{Call: _e.mock.On("Check", ctx, p, name, updates)}	78	+	return &PushHookService_Check_Call{Call: _e.mock.On("Check", ctx, p, name, updates)}
79		}	79		}
80			80
81	-	func (_c PushHooks_Check_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, updates []domain.RefUpdate)) PushHooks_Check_Call {	81	+	func (_c PushHookService_Check_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, updates []domain.RefUpdate)) PushHookService_Check_Call {
82		_c.Call.Run(func(args mock.Arguments) {	82		_c.Call.Run(func(args mock.Arguments) {
83		var arg0 context.Context	83		var arg0 context.Context
84		if args[0] != nil {	84		if args[0] != nil {

@@ -106,18 +106,18 @@ func (_c *PushHooks_Check_Call) Run(run func(ctx context.Context, p domain.Princ
106		return _c	106		return _c
107		}	107		}
108			108
109	-	func (_c PushHooks_Check_Call) Return(err error) PushHooks_Check_Call {	109	+	func (_c PushHookService_Check_Call) Return(err error) PushHookService_Check_Call {
110		_c.Call.Return(err)	110		_c.Call.Return(err)
111		return _c	111		return _c
112		}	112		}
113			113
114	-	func (_c PushHooks_Check_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, updates []domain.RefUpdate) error) PushHooks_Check_Call {	114	+	func (_c PushHookService_Check_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, updates []domain.RefUpdate) error) PushHookService_Check_Call {
115		_c.Call.Return(run)	115		_c.Call.Return(run)
116		return _c	116		return _c
117		}	117		}
118			118
119	-	// Record provides a mock function for the type PushHooks	119	+	// Record provides a mock function for the type PushHookService
120	-	func (_mock *PushHooks) Record(ctx context.Context, p domain.Principal, name domain.RepoName, updates []domain.RefUpdate) error {	120	+	func (_mock *PushHookService) Record(ctx context.Context, p domain.Principal, name domain.RepoName, updates []domain.RefUpdate) error {
121		ret := _mock.Called(ctx, p, name, updates)	121		ret := _mock.Called(ctx, p, name, updates)
122			122
123		if len(ret) == 0 {	123		if len(ret) == 0 {

@@ -133,8 +133,8 @@ func (_mock *PushHooks) Record(ctx context.Context, p domain.Principal, name dom
133		return r0	133		return r0
134		}	134		}
135			135
136	-	// PushHooks_Record_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Record'	136	+	// PushHookService_Record_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Record'
137	-	type PushHooks_Record_Call struct {	137	+	type PushHookService_Record_Call struct {
138		*mock.Call	138		*mock.Call
139		}	139		}
140			140

@@ -143,11 +143,11 @@ type PushHooks_Record_Call struct {
143		// - p domain.Principal	143		// - p domain.Principal
144		// - name domain.RepoName	144		// - name domain.RepoName
145		// - updates []domain.RefUpdate	145		// - updates []domain.RefUpdate
146	-	func (_e PushHooks_Expecter) Record(ctx any, p any, name any, updates any) PushHooks_Record_Call {	146	+	func (_e PushHookService_Expecter) Record(ctx any, p any, name any, updates any) PushHookService_Record_Call {
147	-	return &PushHooks_Record_Call{Call: _e.mock.On("Record", ctx, p, name, updates)}	147	+	return &PushHookService_Record_Call{Call: _e.mock.On("Record", ctx, p, name, updates)}
148		}	148		}
149			149
150	-	func (_c PushHooks_Record_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, updates []domain.RefUpdate)) PushHooks_Record_Call {	150	+	func (_c PushHookService_Record_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, updates []domain.RefUpdate)) PushHookService_Record_Call {
151		_c.Call.Run(func(args mock.Arguments) {	151		_c.Call.Run(func(args mock.Arguments) {
152		var arg0 context.Context	152		var arg0 context.Context
153		if args[0] != nil {	153		if args[0] != nil {

@@ -175,12 +175,12 @@ func (_c *PushHooks_Record_Call) Run(run func(ctx context.Context, p domain.Prin
175		return _c	175		return _c
176		}	176		}
177			177
178	-	func (_c PushHooks_Record_Call) Return(err error) PushHooks_Record_Call {	178	+	func (_c PushHookService_Record_Call) Return(err error) PushHookService_Record_Call {
179		_c.Call.Return(err)	179		_c.Call.Return(err)
180		return _c	180		return _c
181		}	181		}
182			182
183	-	func (_c PushHooks_Record_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, updates []domain.RefUpdate) error) PushHooks_Record_Call {	183	+	func (_c PushHookService_Record_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, updates []domain.RefUpdate) error) PushHookService_Record_Call {
184		_c.Call.Return(run)	184		_c.Call.Return(run)
185		return _c	185		return _c
186		}	186		}

R internal/adapters/githttp/mocks/Pushes.go → internal/ports/mocks/PushService.go +18 -18 renamed, 53% similar


@@ -11,17 +11,17 @@ import (
11		mock "github.com/stretchr/testify/mock"	11		mock "github.com/stretchr/testify/mock"
12		)	12		)
13			13
14	-	// NewPushes creates a new instance of Pushes. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.	14	+	// NewPushService creates a new instance of PushService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15		// The first argument is typically a *testing.T value.	15		// The first argument is typically a *testing.T value.
16	-	func NewPushes(t interface {	16	+	func NewPushService(t interface {
17		mock.TestingT	17		mock.TestingT
18		Cleanup(func())	18		Cleanup(func())
19	-	}) *Pushes {	19	+	}) *PushService {
20		if helper, ok := t.(interface{ Helper() }); ok {	20		if helper, ok := t.(interface{ Helper() }); ok {
21		helper.Helper()	21		helper.Helper()
22		}	22		}
23			23
24	-	mock := &Pushes{}	24	+	mock := &PushService{}
25		mock.Mock.Test(t)	25		mock.Mock.Test(t)
26			26
27		t.Cleanup(func() {	27		t.Cleanup(func() {

@@ -34,21 +34,21 @@ func NewPushes(t interface {
34		return mock	34		return mock
35		}	35		}
36			36
37	-	// Pushes is an autogenerated mock type for the Pushes type	37	+	// PushService is an autogenerated mock type for the PushService type
38	-	type Pushes struct {	38	+	type PushService struct {
39		mock.Mock	39		mock.Mock
40		}	40		}
41			41
42	-	type Pushes_Expecter struct {	42	+	type PushService_Expecter struct {
43		mock *mock.Mock	43		mock *mock.Mock
44		}	44		}
45			45
46	-	func (_m Pushes) EXPECT() Pushes_Expecter {	46	+	func (_m PushService) EXPECT() PushService_Expecter {
47	-	return &Pushes_Expecter{mock: &_m.Mock}	47	+	return &PushService_Expecter{mock: &_m.Mock}
48		}	48		}
49			49
50	-	// Open provides a mock function for the type Pushes	50	+	// Open provides a mock function for the type PushService
51	-	func (_mock *Pushes) Open(ctx context.Context, p domain.Principal, name domain.RepoName, create bool) error {	51	+	func (_mock *PushService) Open(ctx context.Context, p domain.Principal, name domain.RepoName, create bool) error {
52		ret := _mock.Called(ctx, p, name, create)	52		ret := _mock.Called(ctx, p, name, create)
53			53
54		if len(ret) == 0 {	54		if len(ret) == 0 {

@@ -64,8 +64,8 @@ func (_mock *Pushes) Open(ctx context.Context, p domain.Principal, name domain.R
64		return r0	64		return r0
65		}	65		}
66			66
67	-	// Pushes_Open_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Open'	67	+	// PushService_Open_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Open'
68	-	type Pushes_Open_Call struct {	68	+	type PushService_Open_Call struct {
69		*mock.Call	69		*mock.Call
70		}	70		}
71			71

@@ -74,11 +74,11 @@ type Pushes_Open_Call struct {
74		// - p domain.Principal	74		// - p domain.Principal
75		// - name domain.RepoName	75		// - name domain.RepoName
76		// - create bool	76		// - create bool
77	-	func (_e Pushes_Expecter) Open(ctx any, p any, name any, create any) Pushes_Open_Call {	77	+	func (_e PushService_Expecter) Open(ctx any, p any, name any, create any) PushService_Open_Call {
78	-	return &Pushes_Open_Call{Call: _e.mock.On("Open", ctx, p, name, create)}	78	+	return &PushService_Open_Call{Call: _e.mock.On("Open", ctx, p, name, create)}
79		}	79		}
80			80
81	-	func (_c Pushes_Open_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, create bool)) Pushes_Open_Call {	81	+	func (_c PushService_Open_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, create bool)) PushService_Open_Call {
82		_c.Call.Run(func(args mock.Arguments) {	82		_c.Call.Run(func(args mock.Arguments) {
83		var arg0 context.Context	83		var arg0 context.Context
84		if args[0] != nil {	84		if args[0] != nil {

@@ -106,12 +106,12 @@ func (_c *Pushes_Open_Call) Run(run func(ctx context.Context, p domain.Principal
106		return _c	106		return _c
107		}	107		}
108			108
109	-	func (_c Pushes_Open_Call) Return(err error) Pushes_Open_Call {	109	+	func (_c PushService_Open_Call) Return(err error) PushService_Open_Call {
110		_c.Call.Return(err)	110		_c.Call.Return(err)
111		return _c	111		return _c
112		}	112		}
113			113
114	-	func (_c Pushes_Open_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, create bool) error) Pushes_Open_Call {	114	+	func (_c PushService_Open_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, create bool) error) PushService_Open_Call {
115		_c.Call.Return(run)	115		_c.Call.Return(run)
116		return _c	116		return _c
117		}	117		}

R internal/adapters/githttp/mocks/Repos.go → internal/ports/mocks/RepoLookup.go +18 -18 renamed, 58% similar


@@ -11,17 +11,17 @@ import (
11		mock "github.com/stretchr/testify/mock"	11		mock "github.com/stretchr/testify/mock"
12		)	12		)
13			13
14	-	// NewRepos creates a new instance of Repos. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.	14	+	// NewRepoLookup creates a new instance of RepoLookup. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15		// The first argument is typically a *testing.T value.	15		// The first argument is typically a *testing.T value.
16	-	func NewRepos(t interface {	16	+	func NewRepoLookup(t interface {
17		mock.TestingT	17		mock.TestingT
18		Cleanup(func())	18		Cleanup(func())
19	-	}) *Repos {	19	+	}) *RepoLookup {
20		if helper, ok := t.(interface{ Helper() }); ok {	20		if helper, ok := t.(interface{ Helper() }); ok {
21		helper.Helper()	21		helper.Helper()
22		}	22		}
23			23
24	-	mock := &Repos{}	24	+	mock := &RepoLookup{}
25		mock.Mock.Test(t)	25		mock.Mock.Test(t)
26			26
27		t.Cleanup(func() {	27		t.Cleanup(func() {

@@ -34,21 +34,21 @@ func NewRepos(t interface {
34		return mock	34		return mock
35		}	35		}
36			36
37	-	// Repos is an autogenerated mock type for the Repos type	37	+	// RepoLookup is an autogenerated mock type for the RepoLookup type
38	-	type Repos struct {	38	+	type RepoLookup struct {
39		mock.Mock	39		mock.Mock
40		}	40		}
41			41
42	-	type Repos_Expecter struct {	42	+	type RepoLookup_Expecter struct {
43		mock *mock.Mock	43		mock *mock.Mock
44		}	44		}
45			45
46	-	func (_m Repos) EXPECT() Repos_Expecter {	46	+	func (_m RepoLookup) EXPECT() RepoLookup_Expecter {
47	-	return &Repos_Expecter{mock: &_m.Mock}	47	+	return &RepoLookup_Expecter{mock: &_m.Mock}
48		}	48		}
49			49
50	-	// Get provides a mock function for the type Repos	50	+	// Get provides a mock function for the type RepoLookup
51	-	func (_mock *Repos) Get(ctx context.Context, p domain.Principal, name domain.RepoName) (domain.Repo, error) {	51	+	func (_mock *RepoLookup) Get(ctx context.Context, p domain.Principal, name domain.RepoName) (domain.Repo, error) {
52		ret := _mock.Called(ctx, p, name)	52		ret := _mock.Called(ctx, p, name)
53			53
54		if len(ret) == 0 {	54		if len(ret) == 0 {

@@ -73,8 +73,8 @@ func (_mock *Repos) Get(ctx context.Context, p domain.Principal, name domain.Rep
73		return r0, r1	73		return r0, r1
74		}	74		}
75			75
76	-	// Repos_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'	76	+	// RepoLookup_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
77	-	type Repos_Get_Call struct {	77	+	type RepoLookup_Get_Call struct {
78		*mock.Call	78		*mock.Call
79		}	79		}
80			80

@@ -82,11 +82,11 @@ type Repos_Get_Call struct {
82		// - ctx context.Context	82		// - ctx context.Context
83		// - p domain.Principal	83		// - p domain.Principal
84		// - name domain.RepoName	84		// - name domain.RepoName
85	-	func (_e Repos_Expecter) Get(ctx any, p any, name any) Repos_Get_Call {	85	+	func (_e RepoLookup_Expecter) Get(ctx any, p any, name any) RepoLookup_Get_Call {
86	-	return &Repos_Get_Call{Call: _e.mock.On("Get", ctx, p, name)}	86	+	return &RepoLookup_Get_Call{Call: _e.mock.On("Get", ctx, p, name)}
87		}	87		}
88			88
89	-	func (_c Repos_Get_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName)) Repos_Get_Call {	89	+	func (_c RepoLookup_Get_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName)) RepoLookup_Get_Call {
90		_c.Call.Run(func(args mock.Arguments) {	90		_c.Call.Run(func(args mock.Arguments) {
91		var arg0 context.Context	91		var arg0 context.Context
92		if args[0] != nil {	92		if args[0] != nil {

@@ -109,12 +109,12 @@ func (_c *Repos_Get_Call) Run(run func(ctx context.Context, p domain.Principal,
109		return _c	109		return _c
110		}	110		}
111			111
112	-	func (_c Repos_Get_Call) Return(repo domain.Repo, err error) Repos_Get_Call {	112	+	func (_c RepoLookup_Get_Call) Return(repo domain.Repo, err error) RepoLookup_Get_Call {
113		_c.Call.Return(repo, err)	113		_c.Call.Return(repo, err)
114		return _c	114		return _c
115		}	115		}
116			116
117	-	func (_c Repos_Get_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName) (domain.Repo, error)) Repos_Get_Call {	117	+	func (_c RepoLookup_Get_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName) (domain.Repo, error)) RepoLookup_Get_Call {
118		_c.Call.Return(run)	118		_c.Call.Return(run)
119		return _c	119		return _c
120		}	120		}

R internal/adapters/rpc/mocks/Repos.go → internal/ports/mocks/RepoService.go +84 -84 renamed, 50% similar

 import (
 	"context"
-	"bnema.dev/ermite/internal/app"
 	"bnema.dev/ermite/internal/domain"
+	"bnema.dev/ermite/internal/ports"
 	mock "github.com/stretchr/testify/mock"
 )
-// NewRepos creates a new instance of Repos. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
+// NewRepoService creates a new instance of RepoService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
 // The first argument is typically a *testing.T value.
-func NewRepos(t interface {
+func NewRepoService(t interface {
 	mock.TestingT
 	Cleanup(func())
-}) *Repos {
+}) *RepoService {
 	if helper, ok := t.(interface{ Helper() }); ok {
 		helper.Helper()
 	}
-	mock := &Repos{}
+	mock := &RepoService{}
 	mock.Mock.Test(t)
 	t.Cleanup(func() {
 	return mock
 }
-// Repos is an autogenerated mock type for the Repos type
+// RepoService is an autogenerated mock type for the RepoService type
-type Repos struct {
+type RepoService struct {
 	mock.Mock
 }
-type Repos_Expecter struct {
+type RepoService_Expecter struct {
 	mock *mock.Mock
 }
-func (_m *Repos) EXPECT() *Repos_Expecter {
+func (_m *RepoService) EXPECT() *RepoService_Expecter {
-	return &Repos_Expecter{mock: &_m.Mock}
+	return &RepoService_Expecter{mock: &_m.Mock}
 }
-// Create provides a mock function for the type Repos
+// Create provides a mock function for the type RepoService
-func (_mock *Repos) Create(ctx context.Context, p domain.Principal, params app.CreateParams) (domain.Repo, error) {
+func (_mock *RepoService) Create(ctx context.Context, p domain.Principal, params ports.CreateRepoParams) (domain.Repo, error) {
 	ret := _mock.Called(ctx, p, params)
 	if len(ret) == 0 {
 	var r0 domain.Repo
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, app.CreateParams) (domain.Repo, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, ports.CreateRepoParams) (domain.Repo, error)); ok {
 		return returnFunc(ctx, p, params)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, app.CreateParams) domain.Repo); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, ports.CreateRepoParams) domain.Repo); ok {
 		r0 = returnFunc(ctx, p, params)
 	} else {
 		r0 = ret.Get(0).(domain.Repo)
 	}
-	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, app.CreateParams) error); ok {
+	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, ports.CreateRepoParams) error); ok {
 		r1 = returnFunc(ctx, p, params)
 	} else {
 		r1 = ret.Error(1)
 	return r0, r1
 }
-// Repos_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
+// RepoService_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
-type Repos_Create_Call struct {
+type RepoService_Create_Call struct {
 	*mock.Call
 }
 // Create is a helper method to define mock.On call
 //   - ctx context.Context
 //   - p domain.Principal
-//   - params app.CreateParams
+//   - params ports.CreateRepoParams
-func (_e *Repos_Expecter) Create(ctx any, p any, params any) *Repos_Create_Call {
+func (_e *RepoService_Expecter) Create(ctx any, p any, params any) *RepoService_Create_Call {
-	return &Repos_Create_Call{Call: _e.mock.On("Create", ctx, p, params)}
+	return &RepoService_Create_Call{Call: _e.mock.On("Create", ctx, p, params)}
 }
-func (_c *Repos_Create_Call) Run(run func(ctx context.Context, p domain.Principal, params app.CreateParams)) *Repos_Create_Call {
+func (_c *RepoService_Create_Call) Run(run func(ctx context.Context, p domain.Principal, params ports.CreateRepoParams)) *RepoService_Create_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 		if args[1] != nil {
 			arg1 = args[1].(domain.Principal)
 		}
-		var arg2 app.CreateParams
+		var arg2 ports.CreateRepoParams
 		if args[2] != nil {
-			arg2 = args[2].(app.CreateParams)
+			arg2 = args[2].(ports.CreateRepoParams)
 		}
 		run(
 			arg0,
 	return _c
 }
-func (_c *Repos_Create_Call) Return(repo domain.Repo, err error) *Repos_Create_Call {
+func (_c *RepoService_Create_Call) Return(repo domain.Repo, err error) *RepoService_Create_Call {
 	_c.Call.Return(repo, err)
 	return _c
 }
-func (_c *Repos_Create_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, params app.CreateParams) (domain.Repo, error)) *Repos_Create_Call {
+func (_c *RepoService_Create_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, params ports.CreateRepoParams) (domain.Repo, error)) *RepoService_Create_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// Delete provides a mock function for the type Repos
+// Delete provides a mock function for the type RepoService
-func (_mock *Repos) Delete(ctx context.Context, p domain.Principal, name domain.RepoName) error {
+func (_mock *RepoService) Delete(ctx context.Context, p domain.Principal, name domain.RepoName) error {
 	ret := _mock.Called(ctx, p, name)
 	if len(ret) == 0 {
 	return r0
 }
-// Repos_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
+// RepoService_Delete_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Delete'
-type Repos_Delete_Call struct {
+type RepoService_Delete_Call struct {
 	*mock.Call
 }
 //   - ctx context.Context
 //   - p domain.Principal
 //   - name domain.RepoName
-func (_e *Repos_Expecter) Delete(ctx any, p any, name any) *Repos_Delete_Call {
+func (_e *RepoService_Expecter) Delete(ctx any, p any, name any) *RepoService_Delete_Call {
-	return &Repos_Delete_Call{Call: _e.mock.On("Delete", ctx, p, name)}
+	return &RepoService_Delete_Call{Call: _e.mock.On("Delete", ctx, p, name)}
 }
-func (_c *Repos_Delete_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName)) *Repos_Delete_Call {
+func (_c *RepoService_Delete_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName)) *RepoService_Delete_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 	return _c
 }
-func (_c *Repos_Delete_Call) Return(err error) *Repos_Delete_Call {
+func (_c *RepoService_Delete_Call) Return(err error) *RepoService_Delete_Call {
 	_c.Call.Return(err)
 	return _c
 }
-func (_c *Repos_Delete_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName) error) *Repos_Delete_Call {
+func (_c *RepoService_Delete_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName) error) *RepoService_Delete_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// Get provides a mock function for the type Repos
+// Get provides a mock function for the type RepoService
-func (_mock *Repos) Get(ctx context.Context, p domain.Principal, name domain.RepoName) (domain.Repo, error) {
+func (_mock *RepoService) Get(ctx context.Context, p domain.Principal, name domain.RepoName) (domain.Repo, error) {
 	ret := _mock.Called(ctx, p, name)
 	if len(ret) == 0 {
 	return r0, r1
 }
-// Repos_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
+// RepoService_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'
-type Repos_Get_Call struct {
+type RepoService_Get_Call struct {
 	*mock.Call
 }
 //   - ctx context.Context
 //   - p domain.Principal
 //   - name domain.RepoName
-func (_e *Repos_Expecter) Get(ctx any, p any, name any) *Repos_Get_Call {
+func (_e *RepoService_Expecter) Get(ctx any, p any, name any) *RepoService_Get_Call {
-	return &Repos_Get_Call{Call: _e.mock.On("Get", ctx, p, name)}
+	return &RepoService_Get_Call{Call: _e.mock.On("Get", ctx, p, name)}
 }
-func (_c *Repos_Get_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName)) *Repos_Get_Call {
+func (_c *RepoService_Get_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName)) *RepoService_Get_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 	return _c
 }
-func (_c *Repos_Get_Call) Return(repo domain.Repo, err error) *Repos_Get_Call {
+func (_c *RepoService_Get_Call) Return(repo domain.Repo, err error) *RepoService_Get_Call {
 	_c.Call.Return(repo, err)
 	return _c
 }
-func (_c *Repos_Get_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName) (domain.Repo, error)) *Repos_Get_Call {
+func (_c *RepoService_Get_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName) (domain.Repo, error)) *RepoService_Get_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// ListPage provides a mock function for the type Repos
+// ListPage provides a mock function for the type RepoService
-func (_mock *Repos) ListPage(ctx context.Context, p domain.Principal, size int, token string) (app.RepoPage, error) {
+func (_mock *RepoService) ListPage(ctx context.Context, p domain.Principal, size int, token string) (ports.RepoPage, error) {
 	ret := _mock.Called(ctx, p, size, token)
 	if len(ret) == 0 {
 		panic("no return value specified for ListPage")
 	}
-	var r0 app.RepoPage
+	var r0 ports.RepoPage
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, int, string) (app.RepoPage, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, int, string) (ports.RepoPage, error)); ok {
 		return returnFunc(ctx, p, size, token)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, int, string) app.RepoPage); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, int, string) ports.RepoPage); ok {
 		r0 = returnFunc(ctx, p, size, token)
 	} else {
-		r0 = ret.Get(0).(app.RepoPage)
+		r0 = ret.Get(0).(ports.RepoPage)
 	}
 	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, int, string) error); ok {
 		r1 = returnFunc(ctx, p, size, token)
 	return r0, r1
 }
-// Repos_ListPage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPage'
+// RepoService_ListPage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPage'
-type Repos_ListPage_Call struct {
+type RepoService_ListPage_Call struct {
 	*mock.Call
 }
 //   - p domain.Principal
 //   - size int
 //   - token string
-func (_e *Repos_Expecter) ListPage(ctx any, p any, size any, token any) *Repos_ListPage_Call {
+func (_e *RepoService_Expecter) ListPage(ctx any, p any, size any, token any) *RepoService_ListPage_Call {
-	return &Repos_ListPage_Call{Call: _e.mock.On("ListPage", ctx, p, size, token)}
+	return &RepoService_ListPage_Call{Call: _e.mock.On("ListPage", ctx, p, size, token)}
 }
-func (_c *Repos_ListPage_Call) Run(run func(ctx context.Context, p domain.Principal, size int, token string)) *Repos_ListPage_Call {
+func (_c *RepoService_ListPage_Call) Run(run func(ctx context.Context, p domain.Principal, size int, token string)) *RepoService_ListPage_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 	return _c
 }
-func (_c *Repos_ListPage_Call) Return(repoPage app.RepoPage, err error) *Repos_ListPage_Call {
+func (_c *RepoService_ListPage_Call) Return(repoPage ports.RepoPage, err error) *RepoService_ListPage_Call {
 	_c.Call.Return(repoPage, err)
 	return _c
 }
-func (_c *Repos_ListPage_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, size int, token string) (app.RepoPage, error)) *Repos_ListPage_Call {
+func (_c *RepoService_ListPage_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, size int, token string) (ports.RepoPage, error)) *RepoService_ListPage_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// Update provides a mock function for the type Repos
+// Update provides a mock function for the type RepoService
-func (_mock *Repos) Update(ctx context.Context, p domain.Principal, name domain.RepoName, params app.UpdateParams) (domain.Repo, error) {
+func (_mock *RepoService) Update(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.UpdateRepoParams) (domain.Repo, error) {
 	ret := _mock.Called(ctx, p, name, params)
 	if len(ret) == 0 {
 	var r0 domain.Repo
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, app.UpdateParams) (domain.Repo, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.UpdateRepoParams) (domain.Repo, error)); ok {
 		return returnFunc(ctx, p, name, params)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, app.UpdateParams) domain.Repo); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, domain.RepoName, ports.UpdateRepoParams) domain.Repo); ok {
 		r0 = returnFunc(ctx, p, name, params)
 	} else {
 		r0 = ret.Get(0).(domain.Repo)
 	}
-	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, app.UpdateParams) error); ok {
+	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, domain.RepoName, ports.UpdateRepoParams) error); ok {
 		r1 = returnFunc(ctx, p, name, params)
 	} else {
 		r1 = ret.Error(1)
 	return r0, r1
 }
-// Repos_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'
+// RepoService_Update_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Update'
-type Repos_Update_Call struct {
+type RepoService_Update_Call struct {
 	*mock.Call
 }
 //   - ctx context.Context
 //   - p domain.Principal
 //   - name domain.RepoName
-//   - params app.UpdateParams
+//   - params ports.UpdateRepoParams
-func (_e *Repos_Expecter) Update(ctx any, p any, name any, params any) *Repos_Update_Call {
+func (_e *RepoService_Expecter) Update(ctx any, p any, name any, params any) *RepoService_Update_Call {
-	return &Repos_Update_Call{Call: _e.mock.On("Update", ctx, p, name, params)}
+	return &RepoService_Update_Call{Call: _e.mock.On("Update", ctx, p, name, params)}
 }
-func (_c *Repos_Update_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, params app.UpdateParams)) *Repos_Update_Call {
+func (_c *RepoService_Update_Call) Run(run func(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.UpdateRepoParams)) *RepoService_Update_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 		if args[2] != nil {
 			arg2 = args[2].(domain.RepoName)
 		}
-		var arg3 app.UpdateParams
+		var arg3 ports.UpdateRepoParams
 		if args[3] != nil {
-			arg3 = args[3].(app.UpdateParams)
+			arg3 = args[3].(ports.UpdateRepoParams)
 		}
 		run(
 			arg0,
 	return _c
 }
-func (_c *Repos_Update_Call) Return(repo domain.Repo, err error) *Repos_Update_Call {
+func (_c *RepoService_Update_Call) Return(repo domain.Repo, err error) *RepoService_Update_Call {
 	_c.Call.Return(repo, err)
 	return _c
 }
-func (_c *Repos_Update_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, params app.UpdateParams) (domain.Repo, error)) *Repos_Update_Call {
+func (_c *RepoService_Update_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, name domain.RepoName, params ports.UpdateRepoParams) (domain.Repo, error)) *RepoService_Update_Call {
 	_c.Call.Return(run)
 	return _c
 }
-// View provides a mock function for the type Repos
+// View provides a mock function for the type RepoService
-func (_mock *Repos) View(ctx context.Context, repo domain.Repo) (app.RepoView, error) {
+func (_mock *RepoService) View(ctx context.Context, repo domain.Repo) (ports.RepoView, error) {
 	ret := _mock.Called(ctx, repo)
 	if len(ret) == 0 {
 		panic("no return value specified for View")
 	}
-	var r0 app.RepoView
+	var r0 ports.RepoView
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Repo) (app.RepoView, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Repo) (ports.RepoView, error)); ok {
 		return returnFunc(ctx, repo)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Repo) app.RepoView); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Repo) ports.RepoView); ok {
 		r0 = returnFunc(ctx, repo)
 	} else {
-		r0 = ret.Get(0).(app.RepoView)
+		r0 = ret.Get(0).(ports.RepoView)
 	}
 	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Repo) error); ok {
 		r1 = returnFunc(ctx, repo)
 	return r0, r1
 }
-// Repos_View_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'View'
+// RepoService_View_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'View'
-type Repos_View_Call struct {
+type RepoService_View_Call struct {
 	*mock.Call
 }
 // View is a helper method to define mock.On call
 //   - ctx context.Context
 //   - repo domain.Repo
-func (_e *Repos_Expecter) View(ctx any, repo any) *Repos_View_Call {
+func (_e *RepoService_Expecter) View(ctx any, repo any) *RepoService_View_Call {
-	return &Repos_View_Call{Call: _e.mock.On("View", ctx, repo)}
+	return &RepoService_View_Call{Call: _e.mock.On("View", ctx, repo)}
 }
-func (_c *Repos_View_Call) Run(run func(ctx context.Context, repo domain.Repo)) *Repos_View_Call {
+func (_c *RepoService_View_Call) Run(run func(ctx context.Context, repo domain.Repo)) *RepoService_View_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 	return _c
 }
-func (_c *Repos_View_Call) Return(repoView app.RepoView, err error) *Repos_View_Call {
+func (_c *RepoService_View_Call) Return(repoView ports.RepoView, err error) *RepoService_View_Call {
 	_c.Call.Return(repoView, err)
 	return _c
 }
-func (_c *Repos_View_Call) RunAndReturn(run func(ctx context.Context, repo domain.Repo) (app.RepoView, error)) *Repos_View_Call {
+func (_c *RepoService_View_Call) RunAndReturn(run func(ctx context.Context, repo domain.Repo) (ports.RepoView, error)) *RepoService_View_Call {
 	_c.Call.Return(run)
 	return _c
 }

R internal/app/mocks/Revalidator.go → internal/ports/mocks/Revalidator.go +0 -0 renamed, 100% similar

renamed, 100% similar

A internal/ports/mocks/SessionService.go +172 -0

@@ -0,0 +1,172 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"context"
	9	+
	10	+	"bnema.dev/ermite/internal/domain"
	11	+	"bnema.dev/ermite/internal/ports"
	12	+	mock "github.com/stretchr/testify/mock"
	13	+	)
	14	+
	15	+	// NewSessionService creates a new instance of SessionService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	16	+	// The first argument is typically a *testing.T value.
	17	+	func NewSessionService(t interface {
	18	+	mock.TestingT
	19	+	Cleanup(func())
	20	+	}) *SessionService {
	21	+	if helper, ok := t.(interface{ Helper() }); ok {
	22	+	helper.Helper()
	23	+	}
	24	+
	25	+	mock := &SessionService{}
	26	+	mock.Mock.Test(t)
	27	+
	28	+	t.Cleanup(func() {
	29	+	if helper, ok := t.(interface{ Helper() }); ok {
	30	+	helper.Helper()
	31	+	}
	32	+	mock.AssertExpectations(t)
	33	+	})
	34	+
	35	+	return mock
	36	+	}
	37	+
	38	+	// SessionService is an autogenerated mock type for the SessionService type
	39	+	type SessionService struct {
	40	+	mock.Mock
	41	+	}
	42	+
	43	+	type SessionService_Expecter struct {
	44	+	mock *mock.Mock
	45	+	}
	46	+
	47	+	func (_m SessionService) EXPECT() SessionService_Expecter {
	48	+	return &SessionService_Expecter{mock: &_m.Mock}
	49	+	}
	50	+
	51	+	// CreateLoginLink provides a mock function for the type SessionService
	52	+	func (_mock *SessionService) CreateLoginLink(ctx context.Context, p domain.Principal) (ports.LoginLink, error) {
	53	+	ret := _mock.Called(ctx, p)
	54	+
	55	+	if len(ret) == 0 {
	56	+	panic("no return value specified for CreateLoginLink")
	57	+	}
	58	+
	59	+	var r0 ports.LoginLink
	60	+	var r1 error
	61	+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal) (ports.LoginLink, error)); ok {
	62	+	return returnFunc(ctx, p)
	63	+	}
	64	+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal) ports.LoginLink); ok {
	65	+	r0 = returnFunc(ctx, p)
	66	+	} else {
	67	+	r0 = ret.Get(0).(ports.LoginLink)
	68	+	}
	69	+	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal) error); ok {
	70	+	r1 = returnFunc(ctx, p)
	71	+	} else {
	72	+	r1 = ret.Error(1)
	73	+	}
	74	+	return r0, r1
	75	+	}
	76	+
	77	+	// SessionService_CreateLoginLink_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateLoginLink'
	78	+	type SessionService_CreateLoginLink_Call struct {
	79	+	*mock.Call
	80	+	}
	81	+
	82	+	// CreateLoginLink is a helper method to define mock.On call
	83	+	// - ctx context.Context
	84	+	// - p domain.Principal
	85	+	func (_e SessionService_Expecter) CreateLoginLink(ctx any, p any) SessionService_CreateLoginLink_Call {
	86	+	return &SessionService_CreateLoginLink_Call{Call: _e.mock.On("CreateLoginLink", ctx, p)}
	87	+	}
	88	+
	89	+	func (_c SessionService_CreateLoginLink_Call) Run(run func(ctx context.Context, p domain.Principal)) SessionService_CreateLoginLink_Call {
	90	+	_c.Call.Run(func(args mock.Arguments) {
	91	+	var arg0 context.Context
	92	+	if args[0] != nil {
	93	+	arg0 = args[0].(context.Context)
	94	+	}
	95	+	var arg1 domain.Principal
	96	+	if args[1] != nil {
	97	+	arg1 = args[1].(domain.Principal)
	98	+	}
	99	+	run(
	100	+	arg0,
	101	+	arg1,
	102	+	)
	103	+	})
	104	+	return _c
	105	+	}
	106	+
	107	+	func (_c SessionService_CreateLoginLink_Call) Return(loginLink ports.LoginLink, err error) SessionService_CreateLoginLink_Call {
	108	+	_c.Call.Return(loginLink, err)
	109	+	return _c
	110	+	}
	111	+
	112	+	func (_c SessionService_CreateLoginLink_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal) (ports.LoginLink, error)) SessionService_CreateLoginLink_Call {
	113	+	_c.Call.Return(run)
	114	+	return _c
	115	+	}
	116	+
	117	+	// SignOutEverywhere provides a mock function for the type SessionService
	118	+	func (_mock *SessionService) SignOutEverywhere(ctx context.Context, p domain.Principal) error {
	119	+	ret := _mock.Called(ctx, p)
	120	+
	121	+	if len(ret) == 0 {
	122	+	panic("no return value specified for SignOutEverywhere")
	123	+	}
	124	+
	125	+	var r0 error
	126	+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal) error); ok {
	127	+	r0 = returnFunc(ctx, p)
	128	+	} else {
	129	+	r0 = ret.Error(0)
	130	+	}
	131	+	return r0
	132	+	}
	133	+
	134	+	// SessionService_SignOutEverywhere_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SignOutEverywhere'
	135	+	type SessionService_SignOutEverywhere_Call struct {
	136	+	*mock.Call
	137	+	}
	138	+
	139	+	// SignOutEverywhere is a helper method to define mock.On call
	140	+	// - ctx context.Context
	141	+	// - p domain.Principal
	142	+	func (_e SessionService_Expecter) SignOutEverywhere(ctx any, p any) SessionService_SignOutEverywhere_Call {
	143	+	return &SessionService_SignOutEverywhere_Call{Call: _e.mock.On("SignOutEverywhere", ctx, p)}
	144	+	}
	145	+
	146	+	func (_c SessionService_SignOutEverywhere_Call) Run(run func(ctx context.Context, p domain.Principal)) SessionService_SignOutEverywhere_Call {
	147	+	_c.Call.Run(func(args mock.Arguments) {
	148	+	var arg0 context.Context
	149	+	if args[0] != nil {
	150	+	arg0 = args[0].(context.Context)
	151	+	}
	152	+	var arg1 domain.Principal
	153	+	if args[1] != nil {
	154	+	arg1 = args[1].(domain.Principal)
	155	+	}
	156	+	run(
	157	+	arg0,
	158	+	arg1,
	159	+	)
	160	+	})
	161	+	return _c
	162	+	}
	163	+
	164	+	func (_c SessionService_SignOutEverywhere_Call) Return(err error) SessionService_SignOutEverywhere_Call {
	165	+	_c.Call.Return(err)
	166	+	return _c
	167	+	}
	168	+
	169	+	func (_c SessionService_SignOutEverywhere_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal) error) SessionService_SignOutEverywhere_Call {
	170	+	_c.Call.Return(run)
	171	+	return _c
	172	+	}

A internal/ports/mocks/SigningKeyService.go +90 -0

@@ -0,0 +1,90 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"bnema.dev/ermite/internal/domain"
	9	+	mock "github.com/stretchr/testify/mock"
	10	+	)
	11	+
	12	+	// NewSigningKeyService creates a new instance of SigningKeyService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	13	+	// The first argument is typically a *testing.T value.
	14	+	func NewSigningKeyService(t interface {
	15	+	mock.TestingT
	16	+	Cleanup(func())
	17	+	}) *SigningKeyService {
	18	+	if helper, ok := t.(interface{ Helper() }); ok {
	19	+	helper.Helper()
	20	+	}
	21	+
	22	+	mock := &SigningKeyService{}
	23	+	mock.Mock.Test(t)
	24	+
	25	+	t.Cleanup(func() {
	26	+	if helper, ok := t.(interface{ Helper() }); ok {
	27	+	helper.Helper()
	28	+	}
	29	+	mock.AssertExpectations(t)
	30	+	})
	31	+
	32	+	return mock
	33	+	}
	34	+
	35	+	// SigningKeyService is an autogenerated mock type for the SigningKeyService type
	36	+	type SigningKeyService struct {
	37	+	mock.Mock
	38	+	}
	39	+
	40	+	type SigningKeyService_Expecter struct {
	41	+	mock *mock.Mock
	42	+	}
	43	+
	44	+	func (_m SigningKeyService) EXPECT() SigningKeyService_Expecter {
	45	+	return &SigningKeyService_Expecter{mock: &_m.Mock}
	46	+	}
	47	+
	48	+	// Info provides a mock function for the type SigningKeyService
	49	+	func (_mock *SigningKeyService) Info() domain.SigningKeyInfo {
	50	+	ret := _mock.Called()
	51	+
	52	+	if len(ret) == 0 {
	53	+	panic("no return value specified for Info")
	54	+	}
	55	+
	56	+	var r0 domain.SigningKeyInfo
	57	+	if returnFunc, ok := ret.Get(0).(func() domain.SigningKeyInfo); ok {
	58	+	r0 = returnFunc()
	59	+	} else {
	60	+	r0 = ret.Get(0).(domain.SigningKeyInfo)
	61	+	}
	62	+	return r0
	63	+	}
	64	+
	65	+	// SigningKeyService_Info_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Info'
	66	+	type SigningKeyService_Info_Call struct {
	67	+	*mock.Call
	68	+	}
	69	+
	70	+	// Info is a helper method to define mock.On call
	71	+	func (_e SigningKeyService_Expecter) Info() SigningKeyService_Info_Call {
	72	+	return &SigningKeyService_Info_Call{Call: _e.mock.On("Info")}
	73	+	}
	74	+
	75	+	func (_c SigningKeyService_Info_Call) Run(run func()) SigningKeyService_Info_Call {
	76	+	_c.Call.Run(func(args mock.Arguments) {
	77	+	run()
	78	+	})
	79	+	return _c
	80	+	}
	81	+
	82	+	func (_c SigningKeyService_Info_Call) Return(signingKeyInfo domain.SigningKeyInfo) SigningKeyService_Info_Call {
	83	+	_c.Call.Return(signingKeyInfo)
	84	+	return _c
	85	+	}
	86	+
	87	+	func (_c SigningKeyService_Info_Call) RunAndReturn(run func() domain.SigningKeyInfo) SigningKeyService_Info_Call {
	88	+	_c.Call.Return(run)
	89	+	return _c
	90	+	}

A internal/ports/mocks/TokenService.go +262 -0

@@ -0,0 +1,262 @@
	1	+	// Code generated by mockery; DO NOT EDIT.
	2	+	// github.com/vektra/mockery
	3	+	// template: testify
	4	+
	5	+	package mocks
	6	+
	7	+	import (
	8	+	"context"
	9	+
	10	+	"bnema.dev/ermite/internal/domain"
	11	+	"bnema.dev/ermite/internal/ports"
	12	+	mock "github.com/stretchr/testify/mock"
	13	+	)
	14	+
	15	+	// NewTokenService creates a new instance of TokenService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
	16	+	// The first argument is typically a *testing.T value.
	17	+	func NewTokenService(t interface {
	18	+	mock.TestingT
	19	+	Cleanup(func())
	20	+	}) *TokenService {
	21	+	if helper, ok := t.(interface{ Helper() }); ok {
	22	+	helper.Helper()
	23	+	}
	24	+
	25	+	mock := &TokenService{}
	26	+	mock.Mock.Test(t)
	27	+
	28	+	t.Cleanup(func() {
	29	+	if helper, ok := t.(interface{ Helper() }); ok {
	30	+	helper.Helper()
	31	+	}
	32	+	mock.AssertExpectations(t)
	33	+	})
	34	+
	35	+	return mock
	36	+	}
	37	+
	38	+	// TokenService is an autogenerated mock type for the TokenService type
	39	+	type TokenService struct {
	40	+	mock.Mock
	41	+	}
	42	+
	43	+	type TokenService_Expecter struct {
	44	+	mock *mock.Mock
	45	+	}
	46	+
	47	+	func (_m TokenService) EXPECT() TokenService_Expecter {
	48	+	return &TokenService_Expecter{mock: &_m.Mock}
	49	+	}
	50	+
	51	+	// Create provides a mock function for the type TokenService
	52	+	func (_mock *TokenService) Create(ctx context.Context, p domain.Principal, params ports.CreateTokenParams) (ports.CreatedToken, error) {
	53	+	ret := _mock.Called(ctx, p, params)
	54	+
	55	+	if len(ret) == 0 {
	56	+	panic("no return value specified for Create")
	57	+	}
	58	+
	59	+	var r0 ports.CreatedToken
	60	+	var r1 error
	61	+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, ports.CreateTokenParams) (ports.CreatedToken, error)); ok {
	62	+	return returnFunc(ctx, p, params)
	63	+	}
	64	+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, ports.CreateTokenParams) ports.CreatedToken); ok {
	65	+	r0 = returnFunc(ctx, p, params)
	66	+	} else {
	67	+	r0 = ret.Get(0).(ports.CreatedToken)
	68	+	}
	69	+	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, ports.CreateTokenParams) error); ok {
	70	+	r1 = returnFunc(ctx, p, params)
	71	+	} else {
	72	+	r1 = ret.Error(1)
	73	+	}
	74	+	return r0, r1
	75	+	}
	76	+
	77	+	// TokenService_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'
	78	+	type TokenService_Create_Call struct {
	79	+	*mock.Call
	80	+	}
	81	+
	82	+	// Create is a helper method to define mock.On call
	83	+	// - ctx context.Context
	84	+	// - p domain.Principal
	85	+	// - params ports.CreateTokenParams
	86	+	func (_e TokenService_Expecter) Create(ctx any, p any, params any) TokenService_Create_Call {
	87	+	return &TokenService_Create_Call{Call: _e.mock.On("Create", ctx, p, params)}
	88	+	}
	89	+
	90	+	func (_c TokenService_Create_Call) Run(run func(ctx context.Context, p domain.Principal, params ports.CreateTokenParams)) TokenService_Create_Call {
	91	+	_c.Call.Run(func(args mock.Arguments) {
	92	+	var arg0 context.Context
	93	+	if args[0] != nil {
	94	+	arg0 = args[0].(context.Context)
	95	+	}
	96	+	var arg1 domain.Principal
	97	+	if args[1] != nil {
	98	+	arg1 = args[1].(domain.Principal)
	99	+	}
	100	+	var arg2 ports.CreateTokenParams
	101	+	if args[2] != nil {
	102	+	arg2 = args[2].(ports.CreateTokenParams)
	103	+	}
	104	+	run(
	105	+	arg0,
	106	+	arg1,
	107	+	arg2,
	108	+	)
	109	+	})
	110	+	return _c
	111	+	}
	112	+
	113	+	func (_c TokenService_Create_Call) Return(createdToken ports.CreatedToken, err error) TokenService_Create_Call {
	114	+	_c.Call.Return(createdToken, err)
	115	+	return _c
	116	+	}
	117	+
	118	+	func (_c TokenService_Create_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, params ports.CreateTokenParams) (ports.CreatedToken, error)) TokenService_Create_Call {
	119	+	_c.Call.Return(run)
	120	+	return _c
	121	+	}
	122	+
	123	+	// ListPage provides a mock function for the type TokenService
	124	+	func (_mock *TokenService) ListPage(ctx context.Context, p domain.Principal, size int, token string) (ports.TokenPage, error) {
	125	+	ret := _mock.Called(ctx, p, size, token)
	126	+
	127	+	if len(ret) == 0 {
	128	+	panic("no return value specified for ListPage")
	129	+	}
	130	+
	131	+	var r0 ports.TokenPage
	132	+	var r1 error
	133	+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, int, string) (ports.TokenPage, error)); ok {
	134	+	return returnFunc(ctx, p, size, token)
	135	+	}
	136	+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, int, string) ports.TokenPage); ok {
	137	+	r0 = returnFunc(ctx, p, size, token)
	138	+	} else {
	139	+	r0 = ret.Get(0).(ports.TokenPage)
	140	+	}
	141	+	if returnFunc, ok := ret.Get(1).(func(context.Context, domain.Principal, int, string) error); ok {
	142	+	r1 = returnFunc(ctx, p, size, token)
	143	+	} else {
	144	+	r1 = ret.Error(1)
	145	+	}
	146	+	return r0, r1
	147	+	}
	148	+
	149	+	// TokenService_ListPage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPage'
	150	+	type TokenService_ListPage_Call struct {
	151	+	*mock.Call
	152	+	}
	153	+
	154	+	// ListPage is a helper method to define mock.On call
	155	+	// - ctx context.Context
	156	+	// - p domain.Principal
	157	+	// - size int
	158	+	// - token string
	159	+	func (_e TokenService_Expecter) ListPage(ctx any, p any, size any, token any) TokenService_ListPage_Call {
	160	+	return &TokenService_ListPage_Call{Call: _e.mock.On("ListPage", ctx, p, size, token)}
	161	+	}
	162	+
	163	+	func (_c TokenService_ListPage_Call) Run(run func(ctx context.Context, p domain.Principal, size int, token string)) TokenService_ListPage_Call {
	164	+	_c.Call.Run(func(args mock.Arguments) {
	165	+	var arg0 context.Context
	166	+	if args[0] != nil {
	167	+	arg0 = args[0].(context.Context)
	168	+	}
	169	+	var arg1 domain.Principal
	170	+	if args[1] != nil {
	171	+	arg1 = args[1].(domain.Principal)
	172	+	}
	173	+	var arg2 int
	174	+	if args[2] != nil {
	175	+	arg2 = args[2].(int)
	176	+	}
	177	+	var arg3 string
	178	+	if args[3] != nil {
	179	+	arg3 = args[3].(string)
	180	+	}
	181	+	run(
	182	+	arg0,
	183	+	arg1,
	184	+	arg2,
	185	+	arg3,
	186	+	)
	187	+	})
	188	+	return _c
	189	+	}
	190	+
	191	+	func (_c TokenService_ListPage_Call) Return(tokenPage ports.TokenPage, err error) TokenService_ListPage_Call {
	192	+	_c.Call.Return(tokenPage, err)
	193	+	return _c
	194	+	}
	195	+
	196	+	func (_c TokenService_ListPage_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, size int, token string) (ports.TokenPage, error)) TokenService_ListPage_Call {
	197	+	_c.Call.Return(run)
	198	+	return _c
	199	+	}
	200	+
	201	+	// Revoke provides a mock function for the type TokenService
	202	+	func (_mock *TokenService) Revoke(ctx context.Context, p domain.Principal, id string) error {
	203	+	ret := _mock.Called(ctx, p, id)
	204	+
	205	+	if len(ret) == 0 {
	206	+	panic("no return value specified for Revoke")
	207	+	}
	208	+
	209	+	var r0 error
	210	+	if returnFunc, ok := ret.Get(0).(func(context.Context, domain.Principal, string) error); ok {
	211	+	r0 = returnFunc(ctx, p, id)
	212	+	} else {
	213	+	r0 = ret.Error(0)
	214	+	}
	215	+	return r0
	216	+	}
	217	+
	218	+	// TokenService_Revoke_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Revoke'
	219	+	type TokenService_Revoke_Call struct {
	220	+	*mock.Call
	221	+	}
	222	+
	223	+	// Revoke is a helper method to define mock.On call
	224	+	// - ctx context.Context
	225	+	// - p domain.Principal
	226	+	// - id string
	227	+	func (_e TokenService_Expecter) Revoke(ctx any, p any, id any) TokenService_Revoke_Call {
	228	+	return &TokenService_Revoke_Call{Call: _e.mock.On("Revoke", ctx, p, id)}
	229	+	}
	230	+
	231	+	func (_c TokenService_Revoke_Call) Run(run func(ctx context.Context, p domain.Principal, id string)) TokenService_Revoke_Call {
	232	+	_c.Call.Run(func(args mock.Arguments) {
	233	+	var arg0 context.Context
	234	+	if args[0] != nil {
	235	+	arg0 = args[0].(context.Context)
	236	+	}
	237	+	var arg1 domain.Principal
	238	+	if args[1] != nil {
	239	+	arg1 = args[1].(domain.Principal)
	240	+	}
	241	+	var arg2 string
	242	+	if args[2] != nil {
	243	+	arg2 = args[2].(string)
	244	+	}
	245	+	run(
	246	+	arg0,
	247	+	arg1,
	248	+	arg2,
	249	+	)
	250	+	})
	251	+	return _c
	252	+	}
	253	+
	254	+	func (_c TokenService_Revoke_Call) Return(err error) TokenService_Revoke_Call {
	255	+	_c.Call.Return(err)
	256	+	return _c
	257	+	}
	258	+
	259	+	func (_c TokenService_Revoke_Call) RunAndReturn(run func(ctx context.Context, p domain.Principal, id string) error) TokenService_Revoke_Call {
	260	+	_c.Call.Return(run)
	261	+	return _c
	262	+	}

R internal/adapters/web/mocks/SessionAuth.go → internal/ports/mocks/WebSessionService.go +36 -36 renamed, 52% similar


@@ -11,17 +11,17 @@ import (
11		mock "github.com/stretchr/testify/mock"	11		mock "github.com/stretchr/testify/mock"
12		)	12		)
13			13
14	-	// NewSessionAuth creates a new instance of SessionAuth. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.	14	+	// NewWebSessionService creates a new instance of WebSessionService. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
15		// The first argument is typically a *testing.T value.	15		// The first argument is typically a *testing.T value.
16	-	func NewSessionAuth(t interface {	16	+	func NewWebSessionService(t interface {
17		mock.TestingT	17		mock.TestingT
18		Cleanup(func())	18		Cleanup(func())
19	-	}) *SessionAuth {	19	+	}) *WebSessionService {
20		if helper, ok := t.(interface{ Helper() }); ok {	20		if helper, ok := t.(interface{ Helper() }); ok {
21		helper.Helper()	21		helper.Helper()
22		}	22		}
23			23
24	-	mock := &SessionAuth{}	24	+	mock := &WebSessionService{}
25		mock.Mock.Test(t)	25		mock.Mock.Test(t)
26			26
27		t.Cleanup(func() {	27		t.Cleanup(func() {

@@ -34,21 +34,21 @@ func NewSessionAuth(t interface {
34		return mock	34		return mock
35		}	35		}
36			36
37	-	// SessionAuth is an autogenerated mock type for the SessionAuth type	37	+	// WebSessionService is an autogenerated mock type for the WebSessionService type
38	-	type SessionAuth struct {	38	+	type WebSessionService struct {
39		mock.Mock	39		mock.Mock
40		}	40		}
41			41
42	-	type SessionAuth_Expecter struct {	42	+	type WebSessionService_Expecter struct {
43		mock *mock.Mock	43		mock *mock.Mock
44		}	44		}
45			45
46	-	func (_m SessionAuth) EXPECT() SessionAuth_Expecter {	46	+	func (_m WebSessionService) EXPECT() WebSessionService_Expecter {
47	-	return &SessionAuth_Expecter{mock: &_m.Mock}	47	+	return &WebSessionService_Expecter{mock: &_m.Mock}
48		}	48		}
49			49
50	-	// Login provides a mock function for the type SessionAuth	50	+	// Login provides a mock function for the type WebSessionService
51	-	func (_mock *SessionAuth) Login(ctx context.Context, nonce string) (string, time.Duration, error) {	51	+	func (_mock *WebSessionService) Login(ctx context.Context, nonce string) (string, time.Duration, error) {
52		ret := _mock.Called(ctx, nonce)	52		ret := _mock.Called(ctx, nonce)
53			53
54		if len(ret) == 0 {	54		if len(ret) == 0 {

@@ -79,19 +79,19 @@ func (_mock *SessionAuth) Login(ctx context.Context, nonce string) (string, time
79		return r0, r1, r2	79		return r0, r1, r2
80		}	80		}
81			81
82	-	// SessionAuth_Login_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Login'	82	+	// WebSessionService_Login_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Login'
83	-	type SessionAuth_Login_Call struct {	83	+	type WebSessionService_Login_Call struct {
84		*mock.Call	84		*mock.Call
85		}	85		}
86			86
87		// Login is a helper method to define mock.On call	87		// Login is a helper method to define mock.On call
88		// - ctx context.Context	88		// - ctx context.Context
89		// - nonce string	89		// - nonce string
90	-	func (_e SessionAuth_Expecter) Login(ctx any, nonce any) SessionAuth_Login_Call {	90	+	func (_e WebSessionService_Expecter) Login(ctx any, nonce any) WebSessionService_Login_Call {
91	-	return &SessionAuth_Login_Call{Call: _e.mock.On("Login", ctx, nonce)}	91	+	return &WebSessionService_Login_Call{Call: _e.mock.On("Login", ctx, nonce)}
92		}	92		}
93			93
94	-	func (_c SessionAuth_Login_Call) Run(run func(ctx context.Context, nonce string)) SessionAuth_Login_Call {	94	+	func (_c WebSessionService_Login_Call) Run(run func(ctx context.Context, nonce string)) WebSessionService_Login_Call {
95		_c.Call.Run(func(args mock.Arguments) {	95		_c.Call.Run(func(args mock.Arguments) {
96		var arg0 context.Context	96		var arg0 context.Context
97		if args[0] != nil {	97		if args[0] != nil {

@@ -109,18 +109,18 @@ func (_c *SessionAuth_Login_Call) Run(run func(ctx context.Context, nonce string
109		return _c	109		return _c
110		}	110		}
111			111
112	-	func (_c SessionAuth_Login_Call) Return(token string, lifetime time.Duration, err error) SessionAuth_Login_Call {	112	+	func (_c WebSessionService_Login_Call) Return(token string, lifetime time.Duration, err error) WebSessionService_Login_Call {
113		_c.Call.Return(token, lifetime, err)	113		_c.Call.Return(token, lifetime, err)
114		return _c	114		return _c
115		}	115		}
116			116
117	-	func (_c SessionAuth_Login_Call) RunAndReturn(run func(ctx context.Context, nonce string) (string, time.Duration, error)) SessionAuth_Login_Call {	117	+	func (_c WebSessionService_Login_Call) RunAndReturn(run func(ctx context.Context, nonce string) (string, time.Duration, error)) WebSessionService_Login_Call {
118		_c.Call.Return(run)	118		_c.Call.Return(run)
119		return _c	119		return _c
120		}	120		}
121			121
122	-	// LoginLinkValid provides a mock function for the type SessionAuth	122	+	// LoginLinkValid provides a mock function for the type WebSessionService
123	-	func (_mock *SessionAuth) LoginLinkValid(nonce string) bool {	123	+	func (_mock *WebSessionService) LoginLinkValid(nonce string) bool {
124		ret := _mock.Called(nonce)	124		ret := _mock.Called(nonce)
125			125
126		if len(ret) == 0 {	126		if len(ret) == 0 {

@@ -136,18 +136,18 @@ func (_mock *SessionAuth) LoginLinkValid(nonce string) bool {
136		return r0	136		return r0
137		}	137		}
138			138
139	-	// SessionAuth_LoginLinkValid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoginLinkValid'	139	+	// WebSessionService_LoginLinkValid_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoginLinkValid'
140	-	type SessionAuth_LoginLinkValid_Call struct {	140	+	type WebSessionService_LoginLinkValid_Call struct {
141		*mock.Call	141		*mock.Call
142		}	142		}
143			143
144		// LoginLinkValid is a helper method to define mock.On call	144		// LoginLinkValid is a helper method to define mock.On call
145		// - nonce string	145		// - nonce string
146	-	func (_e SessionAuth_Expecter) LoginLinkValid(nonce any) SessionAuth_LoginLinkValid_Call {	146	+	func (_e WebSessionService_Expecter) LoginLinkValid(nonce any) WebSessionService_LoginLinkValid_Call {
147	-	return &SessionAuth_LoginLinkValid_Call{Call: _e.mock.On("LoginLinkValid", nonce)}	147	+	return &WebSessionService_LoginLinkValid_Call{Call: _e.mock.On("LoginLinkValid", nonce)}
148		}	148		}
149			149
150	-	func (_c SessionAuth_LoginLinkValid_Call) Run(run func(nonce string)) SessionAuth_LoginLinkValid_Call {	150	+	func (_c WebSessionService_LoginLinkValid_Call) Run(run func(nonce string)) WebSessionService_LoginLinkValid_Call {
151		_c.Call.Run(func(args mock.Arguments) {	151		_c.Call.Run(func(args mock.Arguments) {
152		var arg0 string	152		var arg0 string
153		if args[0] != nil {	153		if args[0] != nil {

@@ -160,18 +160,18 @@ func (_c SessionAuth_LoginLinkValid_Call) Run(run func(nonce string)) SessionA
160		return _c	160		return _c
161		}	161		}
162			162
163	-	func (_c SessionAuth_LoginLinkValid_Call) Return(b bool) SessionAuth_LoginLinkValid_Call {	163	+	func (_c WebSessionService_LoginLinkValid_Call) Return(b bool) WebSessionService_LoginLinkValid_Call {
164		_c.Call.Return(b)	164		_c.Call.Return(b)
165		return _c	165		return _c
166		}	166		}
167			167
168	-	func (_c SessionAuth_LoginLinkValid_Call) RunAndReturn(run func(nonce string) bool) SessionAuth_LoginLinkValid_Call {	168	+	func (_c WebSessionService_LoginLinkValid_Call) RunAndReturn(run func(nonce string) bool) WebSessionService_LoginLinkValid_Call {
169		_c.Call.Return(run)	169		_c.Call.Return(run)
170		return _c	170		return _c
171		}	171		}
172			172
173	-	// Verify provides a mock function for the type SessionAuth	173	+	// Verify provides a mock function for the type WebSessionService
174	-	func (_mock *SessionAuth) Verify(ctx context.Context, token string) (context.Context, bool, error) {	174	+	func (_mock *WebSessionService) Verify(ctx context.Context, token string) (context.Context, bool, error) {
175		ret := _mock.Called(ctx, token)	175		ret := _mock.Called(ctx, token)
176			176
177		if len(ret) == 0 {	177		if len(ret) == 0 {

@@ -204,19 +204,19 @@ func (_mock *SessionAuth) Verify(ctx context.Context, token string) (context.Con
204		return r0, r1, r2	204		return r0, r1, r2
205		}	205		}
206			206
207	-	// SessionAuth_Verify_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Verify'	207	+	// WebSessionService_Verify_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Verify'
208	-	type SessionAuth_Verify_Call struct {	208	+	type WebSessionService_Verify_Call struct {
209		*mock.Call	209		*mock.Call
210		}	210		}
211			211
212		// Verify is a helper method to define mock.On call	212		// Verify is a helper method to define mock.On call
213		// - ctx context.Context	213		// - ctx context.Context
214		// - token string	214		// - token string
215	-	func (_e SessionAuth_Expecter) Verify(ctx any, token any) SessionAuth_Verify_Call {	215	+	func (_e WebSessionService_Expecter) Verify(ctx any, token any) WebSessionService_Verify_Call {
216	-	return &SessionAuth_Verify_Call{Call: _e.mock.On("Verify", ctx, token)}	216	+	return &WebSessionService_Verify_Call{Call: _e.mock.On("Verify", ctx, token)}
217		}	217		}
218			218
219	-	func (_c SessionAuth_Verify_Call) Run(run func(ctx context.Context, token string)) SessionAuth_Verify_Call {	219	+	func (_c WebSessionService_Verify_Call) Run(run func(ctx context.Context, token string)) WebSessionService_Verify_Call {
220		_c.Call.Run(func(args mock.Arguments) {	220		_c.Call.Run(func(args mock.Arguments) {
221		var arg0 context.Context	221		var arg0 context.Context
222		if args[0] != nil {	222		if args[0] != nil {

@@ -234,12 +234,12 @@ func (_c *SessionAuth_Verify_Call) Run(run func(ctx context.Context, token strin
234		return _c	234		return _c
235		}	235		}
236			236
237	-	func (_c SessionAuth_Verify_Call) Return(owner context.Context, ok bool, err error) SessionAuth_Verify_Call {	237	+	func (_c WebSessionService_Verify_Call) Return(owner context.Context, ok bool, err error) WebSessionService_Verify_Call {
238		_c.Call.Return(owner, ok, err)	238		_c.Call.Return(owner, ok, err)
239		return _c	239		return _c
240		}	240		}
241			241
242	-	func (_c SessionAuth_Verify_Call) RunAndReturn(run func(ctx context.Context, token string) (context.Context, bool, error)) SessionAuth_Verify_Call {	242	+	func (_c WebSessionService_Verify_Call) RunAndReturn(run func(ctx context.Context, token string) (context.Context, bool, error)) WebSessionService_Verify_Call {
243		_c.Call.Return(run)	243		_c.Call.Return(run)
244		return _c	244		return _c
245		}	245		}

M internal/ports/ports.go +9 -2

 // SPDX-License-Identifier: AGPL-3.0-or-later
-// Package ports declares the interfaces the use cases need from the outside
+// Package ports declares every interface that crosses a layer, and the
-// world. Adapters implement them; cmd wires them.
+// parameter and result types of the use case interfaces.
+//
+// Outbound ports (ports.go) are what the use cases need from the outside
+// world: adapters implement them. Inbound ports (services.go) are the use
+// cases as the adapters that serve requests see them: the types of package app
+// implement them. Adapters and app depend on this package and on domain, never
+// on each other; cmd wires the implementations. All the mocks are generated in
+// ports/mocks.
 package ports
 import (

A internal/ports/services.go +162 -0

@@ -0,0 +1,162 @@
	1	+	// SPDX-License-Identifier: AGPL-3.0-or-later
	2	+
	3	+	package ports
	4	+
	5	+	import (
	6	+	"context"
	7	+	"errors"
	8	+	"io"
	9	+	"time"
	10	+
	11	+	"bnema.dev/ermite/internal/domain"
	12	+	)
	13	+
	14	+	// The interfaces below are the use cases as the inbound adapters (the API,
	15	+	// Git over HTTP, the web) and the entrypoint see them. The types of package
	16	+	// app implement them, each assertion being made in app; the mocks in
	17	+	// ports/mocks stand in for them in the tests of the adapters.
	18	+
	19	+	// AuthService turns the secret of a request into a principal. It returns
	20	+	// domain.ErrUnauthenticated for a secret that is not valid. *app.Auth
	21	+	// implements it.
	22	+	type AuthService interface {
	23	+	Authenticate(ctx context.Context, secret string) (domain.Principal, error)
	24	+	}
	25	+
	26	+	// Revalidator confirms that a principal obtained earlier is still
	27	+	// authorized. *app.Auth implements it.
	28	+	type Revalidator interface {
	29	+	Revalidate(ctx context.Context, p domain.Principal) error
	30	+	}
	31	+
	32	+	// RepoLookup is the read side of a single repository. A repository the
	33	+	// principal may not read is domain.ErrNotFound. *app.Repos implements it, as
	34	+	// part of RepoService.
	35	+	type RepoLookup interface {
	36	+	Get(ctx context.Context, p domain.Principal, name domain.RepoName) (domain.Repo, error)
	37	+	}
	38	+
	39	+	// RepoService is the repository use cases the API serves. *app.Repos
	40	+	// implements it.
	41	+	type RepoService interface {
	42	+	RepoLookup
	43	+	ListPage(ctx context.Context, p domain.Principal, size int, token string) (RepoPage, error)
	44	+	View(ctx context.Context, repo domain.Repo) (RepoView, error)
	45	+	Create(ctx context.Context, p domain.Principal, params CreateRepoParams) (domain.Repo, error)
	46	+	Update(ctx context.Context, p domain.Principal, name domain.RepoName, params UpdateRepoParams) (domain.Repo, error)
	47	+	Delete(ctx context.Context, p domain.Principal, name domain.RepoName) error
	48	+	}
	49	+
	50	+	// TokenService is the access token use cases the API serves. *app.Tokens
	51	+	// implements it.
	52	+	type TokenService interface {
	53	+	Create(ctx context.Context, p domain.Principal, params CreateTokenParams) (CreatedToken, error)
	54	+	ListPage(ctx context.Context, p domain.Principal, size int, token string) (TokenPage, error)
	55	+	Revoke(ctx context.Context, p domain.Principal, id string) error
	56	+	}
	57	+
	58	+	// BrowseService is the read side of a repository's content. *app.Browse
	59	+	// implements it.
	60	+	type BrowseService interface {
	61	+	ListRefs(ctx context.Context, p domain.Principal, repo domain.RepoName, params ListRefsParams) (RefPage, error)
	62	+	ResolveRevision(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision) (domain.ResolvedRevision, error)
	63	+	GetTree(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision, path domain.TreePath, includeLastCommit bool) (domain.Tree, error)
	64	+	OpenBlob(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision, path domain.TreePath) (domain.BlobInfo, io.ReadCloser, error)
	65	+	ListCommits(ctx context.Context, p domain.Principal, repo domain.RepoName, params ListCommitsParams) (HistoryPage, error)
	66	+	GetCommit(ctx context.Context, p domain.Principal, repo domain.RepoName, rev domain.Revision) (domain.CommitDetail, error)
	67	+	}
	68	+
	69	+	// EventService streams the events of the forge. *app.Events implements it.
	70	+	type EventService interface {
	71	+	Watch(ctx context.Context, p domain.Principal, params WatchParams, send func(WatchEvent) error) error
	72	+	}
	73	+
	74	+	// MergeRequestService is the merge request use cases. *app.MergeRequests
	75	+	// implements it.
	76	+	type MergeRequestService interface {
	77	+	Create(ctx context.Context, p domain.Principal, name domain.RepoName, params CreateMergeRequestParams) (domain.MergeRequest, error)
	78	+	List(ctx context.Context, p domain.Principal, name domain.RepoName, params ListMergeRequestsParams) (MergeRequestPage, error)
	79	+	Get(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, sinceLastRead bool) (MergeRequestDetail, error)
	80	+	AddComment(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params AddCommentParams) (domain.Comment, error)
	81	+	ResolveComment(ctx context.Context, p domain.Principal, name domain.RepoName, number, commentID int64, resolved bool) (domain.Comment, error)
	82	+	Close(ctx context.Context, p domain.Principal, name domain.RepoName, number int64) (domain.MergeRequest, error)
	83	+	MarkRead(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, head domain.ObjectID) (domain.ObjectID, error)
	84	+	Merge(ctx context.Context, p domain.Principal, name domain.RepoName, number int64, params MergeParams) (MergeResult, error)
	85	+	}
	86	+
	87	+	// SigningKeyService tells which key signs the commits of the forge.
	88	+	// *app.SigningKey implements it.
	89	+	type SigningKeyService interface {
	90	+	Info() domain.SigningKeyInfo
	91	+	}
	92	+
	93	+	// SessionService is the owner's web session use cases the API serves.
	94	+	// *app.Sessions implements it.
	95	+	type SessionService interface {
	96	+	CreateLoginLink(ctx context.Context, p domain.Principal) (LoginLink, error)
	97	+	SignOutEverywhere(ctx context.Context, p domain.Principal) error
	98	+	}
	99	+
	100	+	// ErrLinkRejected is what WebSessionService.Login returns for a link that is
	101	+	// unknown, expired or already used.
	102	+	var ErrLinkRejected = errors.New("login link rejected")
	103	+
	104	+	// WebSessionService is the session side of the use cases, as the web needs
	105	+	// it. The entrypoint implements it over *app.Sessions.
	106	+	type WebSessionService interface {
	107	+	// LoginLinkValid reports whether the link is pending, without using it.
	108	+	LoginLinkValid(nonce string) bool
	109	+	// Login uses the link and returns the session token and how long it
	110	+	// lasts, or ErrLinkRejected.
	111	+	Login(ctx context.Context, nonce string) (token string, lifetime time.Duration, err error)
	112	+	// Verify checks a session token. When it is valid it returns the context
	113	+	// to serve the request with, which carries the owner as the caller of the
	114	+	// API; when it is not, ok is false and err nil. An error means the check
	115	+	// could not be made (the request then runs as anonymous).
	116	+	Verify(ctx context.Context, token string) (owner context.Context, ok bool, err error)
	117	+	}
	118	+
	119	+	// PushService opens a repository for a push: it is domain.ErrUnauthenticated
	120	+	// for an anonymous caller, domain.ErrNotFound for a repository the caller may
	121	+	// not write and cannot see (or that is missing and may not be created),
	122	+	// domain.ErrForbidden for one it can see but not write. With create, a
	123	+	// missing repository the principal may write is created. *app.Pushes
	124	+	// implements it.
	125	+	type PushService interface {
	126	+	Open(ctx context.Context, p domain.Principal, name domain.RepoName, create bool) error
	127	+	}
	128	+
	129	+	// PushHookService is what the hook socket asks of the use cases.
	130	+	// *app.Pushes implements it.
	131	+	type PushHookService interface {
	132	+	// Check decides a push before Git applies it; an error matching
	133	+	// domain.ErrRejected refuses it, any other error refuses it as a failure.
	134	+	Check(ctx context.Context, p domain.Principal, name domain.RepoName, updates []domain.RefUpdate) error
	135	+	// Record handles an accepted push.
	136	+	Record(ctx context.Context, p domain.Principal, name domain.RepoName, updates []domain.RefUpdate) error
	137	+	}
	138	+
	139	+	// MaintenanceScheduler queues repository maintenance. *app.Maintainer
	140	+	// implements it.
	141	+	type MaintenanceScheduler interface {
	142	+	Schedule(ctx context.Context, name domain.RepoName)
	143	+	}
	144	+
	145	+	// HookTokens hands out the per-request tokens the hooks of a push present
	146	+	// back to ermite, and the socket they present them on. The Git HTTP adapter
	147	+	// implements it.
	148	+	type HookTokens interface {
	149	+	// Register binds a new token to the repository and principal of a push.
	150	+	// release revokes it and must be called when the request ends.
	151	+	Register(ctx context.Context, repo domain.RepoName, p domain.Principal) (token string, release func())
	152	+	// Socket is the path of the hook socket.
	153	+	Socket() string
	154	+	}
	155	+
	156	+	// FailureLimiter counts the failed authentications per client. The adapters
	157	+	// that authenticate share one, so that a client has one budget of failures.
	158	+	// *clientlimit.Limiter implements it.
	159	+	type FailureLimiter interface {
	160	+	Blocked(ctx context.Context, addr string) (bool, time.Duration)
	161	+	Fail(ctx context.Context, addr string)
	162	+	}