1// SPDX-License-Identifier: AGPL-3.0-or-later
2
3package rpc
4
5import (
6 "context"
7 "fmt"
8
9 "connectrpc.com/connect"
10
11 pb "bnema.dev/ermite-api/gen/ermite"
12 "bnema.dev/ermite/internal/domain"
13 "bnema.dev/ermite/internal/ports"
14)
15
16// repoService implements ermiteconnect.RepoServiceHandler.
17type repoService struct{ repos ports.RepoService }
18
19func (s *repoService) ListRepos(ctx context.Context, req *connect.Request[pb.ListReposRequest]) (*connect.Response[pb.ListReposResponse], error) {
20 page, err := s.repos.ListPage(ctx, caller(ctx), int(req.Msg.GetPageSize()), req.Msg.GetPageToken())
21 if err != nil {
22 return nil, connectError(ctx, err)
23 }
24 out := &pb.ListReposResponse{NextPageToken: page.NextPageToken, Repos: make([]*pb.Repo, 0, len(page.Repos))}
25 for _, repo := range page.Repos {
26 view, err := s.repos.View(ctx, repo)
27 if err != nil {
28 return nil, connectError(ctx, err)
29 }
30 out.Repos = append(out.Repos, repoToPB(view))
31 }
32 return connect.NewResponse(out), nil
33}
34
35func (s *repoService) GetRepo(ctx context.Context, req *connect.Request[pb.GetRepoRequest]) (*connect.Response[pb.GetRepoResponse], error) {
36 name, err := domain.ParseRepoName(req.Msg.GetRepo())
37 if err != nil {
38 return nil, connectError(ctx, err)
39 }
40 repo, err := s.repos.Get(ctx, caller(ctx), name)
41 if err != nil {
42 return nil, connectError(ctx, err)
43 }
44 return respondRepo(ctx, s.repos, repo, func(r *pb.Repo) *pb.GetRepoResponse { return &pb.GetRepoResponse{Repo: r} })
45}
46
47func (s *repoService) CreateRepo(ctx context.Context, req *connect.Request[pb.CreateRepoRequest]) (*connect.Response[pb.CreateRepoResponse], error) {
48 name, err := domain.ParseRepoName(req.Msg.GetName())
49 if err != nil {
50 return nil, connectError(ctx, err)
51 }
52 vis, err := visibilityFromPB(req.Msg.GetVisibility())
53 if err != nil {
54 return nil, connectError(ctx, err)
55 }
56 repo, err := s.repos.Create(ctx, caller(ctx), ports.CreateRepoParams{
57 Name: name, Description: req.Msg.GetDescription(), Topics: req.Msg.GetTopics(), Visibility: vis,
58 })
59 if err != nil {
60 return nil, connectError(ctx, err)
61 }
62 return respondRepo(ctx, s.repos, repo, func(r *pb.Repo) *pb.CreateRepoResponse { return &pb.CreateRepoResponse{Repo: r} })
63}
64
65func (s *repoService) UpdateRepo(ctx context.Context, req *connect.Request[pb.UpdateRepoRequest]) (*connect.Response[pb.UpdateRepoResponse], error) {
66 name, err := domain.ParseRepoName(req.Msg.GetRepo())
67 if err != nil {
68 return nil, connectError(ctx, err)
69 }
70 params, err := updateParams(req.Msg)
71 if err != nil {
72 return nil, connectError(ctx, err)
73 }
74 repo, err := s.repos.Update(ctx, caller(ctx), name, params)
75 if err != nil {
76 return nil, connectError(ctx, err)
77 }
78 return respondRepo(ctx, s.repos, repo, func(r *pb.Repo) *pb.UpdateRepoResponse { return &pb.UpdateRepoResponse{Repo: r} })
79}
80
81// updateParams maps the field mask of an update. The mask must name at least
82// one of "description", "topics", "visibility", "default_branch", "settings",
83// "settings.allowed_merge_modes" and "settings.failing_checks_block", and
84// nothing else.
85//
86//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
87func updateParams(msg *pb.UpdateRepoRequest) (ports.UpdateRepoParams, error) {
88 var params ports.UpdateRepoParams
89 paths := msg.GetUpdateMask().GetPaths()
90 if len(paths) == 0 {
91 return params, fmt.Errorf("%w: update_mask is empty", domain.ErrInvalid)
92 }
93 for _, path := range paths {
94 switch path {
95 case "description":
96 params.Description = new(msg.GetDescription())
97 case "topics":
98 params.Topics = new(msg.GetTopics())
99 case "visibility":
100 vis, err := visibilityFromPB(msg.GetVisibility())
101 if err != nil {
102 return params, err
103 }
104 if vis == "" {
105 return params, fmt.Errorf("%w: visibility is unspecified", domain.ErrInvalid)
106 }
107 params.Visibility = &vis
108 case "default_branch":
109 params.DefaultBranch = new(msg.GetDefaultBranch())
110 case "settings", "settings.allowed_merge_modes", "settings.failing_checks_block":
111 if path != "settings.failing_checks_block" {
112 modes, err := mergeModesFromPB(msg.GetSettings().GetAllowedMergeModes())
113 if err != nil {
114 return params, err
115 }
116 params.AllowedMergeModes = &modes
117 }
118 if path != "settings.allowed_merge_modes" {
119 params.FailingChecksBlock = new(msg.GetSettings().GetFailingChecksBlock())
120 }
121 default:
122 return params, fmt.Errorf("%w: unknown path %q in update_mask", domain.ErrInvalid, path)
123 }
124 }
125 return params, nil
126}
127
128func (s *repoService) DeleteRepo(ctx context.Context, req *connect.Request[pb.DeleteRepoRequest]) (*connect.Response[pb.DeleteRepoResponse], error) {
129 name, err := domain.ParseRepoName(req.Msg.GetRepo())
130 if err != nil {
131 return nil, connectError(ctx, err)
132 }
133 if err := s.repos.Delete(ctx, caller(ctx), name); err != nil {
134 return nil, connectError(ctx, err)
135 }
136 return connect.NewResponse(&pb.DeleteRepoResponse{}), nil
137}
138
139// respondRepo adds the default branch to repo and wraps it in a response.
140func respondRepo[T any](ctx context.Context, repos ports.RepoService, repo domain.Repo, wrap func(*pb.Repo) *T) (*connect.Response[T], error) {
141 view, err := repos.View(ctx, repo)
142 if err != nil {
143 return nil, connectError(ctx, err)
144 }
145 return connect.NewResponse(wrap(repoToPB(view))), nil
146}