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