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; the optional issues field stands outside the mask, and alone
85// it is a valid update.
86//
87//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
88func updateParams(msg *pb.UpdateRepoRequest) (ports.UpdateRepoParams, error) {
89 var params ports.UpdateRepoParams
90 paths := msg.GetUpdateMask().GetPaths()
91 if len(paths) == 0 && msg.Issues == nil {
92 return params, fmt.Errorf("%w: update_mask is empty", domain.ErrInvalid)
93 }
94 if msg.Issues != nil {
95 mode, err := issuesModeFromPB(msg.GetIssues())
96 if err != nil {
97 return params, err
98 }
99 params.Issues = &mode
100 }
101 for _, path := range paths {
102 switch path {
103 case "description":
104 params.Description = new(msg.GetDescription())
105 case "topics":
106 params.Topics = new(msg.GetTopics())
107 case "visibility":
108 vis, err := visibilityFromPB(msg.GetVisibility())
109 if err != nil {
110 return params, err
111 }
112 if vis == "" {
113 return params, fmt.Errorf("%w: visibility is unspecified", domain.ErrInvalid)
114 }
115 params.Visibility = &vis
116 case "default_branch":
117 params.DefaultBranch = new(msg.GetDefaultBranch())
118 case "settings", "settings.allowed_merge_modes", "settings.failing_checks_block":
119 if path != "settings.failing_checks_block" {
120 modes, err := mergeModesFromPB(msg.GetSettings().GetAllowedMergeModes())
121 if err != nil {
122 return params, err
123 }
124 params.AllowedMergeModes = &modes
125 }
126 if path != "settings.allowed_merge_modes" {
127 params.FailingChecksBlock = new(msg.GetSettings().GetFailingChecksBlock())
128 }
129 default:
130 return params, fmt.Errorf("%w: unknown path %q in update_mask", domain.ErrInvalid, path)
131 }
132 }
133 return params, nil
134}
135
136func (s *repoService) DeleteRepo(ctx context.Context, req *connect.Request[pb.DeleteRepoRequest]) (*connect.Response[pb.DeleteRepoResponse], error) {
137 name, err := domain.ParseRepoName(req.Msg.GetRepo())
138 if err != nil {
139 return nil, connectError(ctx, err)
140 }
141 if err := s.repos.Delete(ctx, caller(ctx), name); err != nil {
142 return nil, connectError(ctx, err)
143 }
144 return connect.NewResponse(&pb.DeleteRepoResponse{}), nil
145}
146
147// respondRepo adds the default branch to repo and wraps it in a response.
148func respondRepo[T any](ctx context.Context, repos ports.RepoService, repo domain.Repo, wrap func(*pb.Repo) *T) (*connect.Response[T], error) {
149 view, err := repos.View(ctx, repo)
150 if err != nil {
151 return nil, connectError(ctx, err)
152 }
153 return connect.NewResponse(wrap(repoToPB(view))), nil
154}