feat: Added new ListRolesApi

api/handler/v1beta1/appeal.go

@@ -7,6 +7,7 @@ import (
 	guardianv1beta1 "github.com/goto/guardian/api/proto/gotocompany/guardian/v1beta1"
 	"github.com/goto/guardian/core/appeal"
 	"github.com/goto/guardian/domain"
+	"golang.org/x/sync/errgroup"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
@@ -35,27 +36,36 @@ func (s *GRPCServer) ListUserAppeals(ctx context.Context, req *guardianv1beta1.L
 	if req.GetResourceTypes() != nil {
 		filters.ResourceTypes = req.GetResourceTypes()
 	}
+	if req.GetAccountTypes() != nil {
+		filters.AccountTypes = req.GetAccountTypes()
+	}
 	if req.GetResourceUrns() != nil {
 		filters.ResourceURNs = req.GetResourceUrns()
 	}
 	if req.GetOrderBy() != nil {
 		filters.OrderBy = req.GetOrderBy()
 	}
+	if req.GetQ() != "" {
+		filters.Q = req.GetQ()
+	}
 	filters.Offset = int(req.GetOffset())
 	filters.Size = int(req.GetSize())
 
-	appeals, err := s.listAppeals(ctx, filters)
+	appeals, total, err := s.listAppeals(ctx, filters)
 	if err != nil {
 		return nil, err
 	}
 
 	return &guardianv1beta1.ListUserAppealsResponse{
 		Appeals: appeals,
+		Total:   int32(total),
 	}, nil
 }
 
 func (s *GRPCServer) ListAppeals(ctx context.Context, req *guardianv1beta1.ListAppealsRequest) (*guardianv1beta1.ListAppealsResponse, error) {
 	filters := &domain.ListAppealsFilter{
+		Q:             req.GetQ(),
+		AccountTypes:  req.GetAccountTypes(),
 		AccountID:     req.GetAccountId(),
 		Statuses:      req.GetStatuses(),
 		Role:          req.GetRole(),
@@ -67,13 +77,14 @@ func (s *GRPCServer) ListAppeals(ctx context.Context, req *guardianv1beta1.ListA
 		Offset:        int(req.GetOffset()),
 		OrderBy:       req.GetOrderBy(),
 	}
-	appeals, err := s.listAppeals(ctx, filters)
+	appeals, total, err := s.listAppeals(ctx, filters)
 	if err != nil {
 		return nil, err
 	}
 
 	return &guardianv1beta1.ListAppealsResponse{
 		Appeals: appeals,
+		Total:   int32(total),
 	}, nil
 }
 
@@ -166,20 +177,40 @@ func (s *GRPCServer) CancelAppeal(ctx context.Context, req *guardianv1beta1.Canc
 	}, nil
 }
 
-func (s *GRPCServer) listAppeals(ctx context.Context, filters *domain.ListAppealsFilter) ([]*guardianv1beta1.Appeal, error) {
-	appeals, err := s.appealService.Find(ctx, filters)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "failed to get appeal list: %s", err)
+func (s *GRPCServer) listAppeals(ctx context.Context, filters *domain.ListAppealsFilter) ([]*guardianv1beta1.Appeal, int64, error) {
+	eg, ctx := errgroup.WithContext(ctx)
+	var appeals []*domain.Appeal
+	var total int64
+
+	eg.Go(func() error {
+		appealRecords, err := s.appealService.Find(ctx, filters)
+		if err != nil {
+			return status.Errorf(codes.Internal, "failed to get appeal list: %s", err)
+		}
+		appeals = appealRecords
+		return nil
+	})
+	eg.Go(func() error {
+		totalRecord, err := s.appealService.GetAppealsTotalCount(ctx, filters)
+		if err != nil {
+			return status.Errorf(codes.Internal, "failed to get appeal total count: %s", err)
+		}
+		total = totalRecord
+		return nil
+	})
+
+	if err := eg.Wait(); err != nil {
+		return nil, 0, err
 	}
 
 	appealProtos := []*guardianv1beta1.Appeal{}
 	for _, a := range appeals {
 		appealProto, err := s.adapter.ToAppealProto(a)
 		if err != nil {
-			return nil, status.Errorf(codes.Internal, "failed to parse appeal: %s", err)
+			return nil, 0, status.Errorf(codes.Internal, "failed to parse appeal: %s", err)
 		}
 		appealProtos = append(appealProtos, appealProto)
 	}
 
-	return appealProtos, nil
+	return appealProtos, total, nil
 }

api/handler/v1beta1/appeal_test.go

@@ -3,6 +3,7 @@ package v1beta1_test
 import (
 	"context"
 	"errors"
+	"fmt"
 	"time"
 
 	"github.com/google/uuid"
@@ -33,6 +34,8 @@ func (s *GrpcHandlersSuite) TestListUserAppeals() {
 			ResourceTypes: []string{"test-resource-type"},
 			ResourceURNs:  []string{"test-resource-urn"},
 			OrderBy:       []string{"test-order"},
+			AccountTypes:  []string{"test-account-type"},
+			Q:             "test",
 		}
 		expectedAppeals := []*domain.Appeal{
 			{
@@ -117,9 +120,12 @@ func (s *GrpcHandlersSuite) TestListUserAppeals() {
 					UpdatedAt: timestamppb.New(timeNow),
 				},
 			},
+			Total: 1,
 		}
-		s.appealService.EXPECT().Find(mock.AnythingOfType("*context.valueCtx"), expectedFilters).
+		s.appealService.EXPECT().Find(mock.AnythingOfType("*context.cancelCtx"), expectedFilters).
 			Return(expectedAppeals, nil).Once()
+		s.appealService.EXPECT().GetAppealsTotalCount(mock.AnythingOfType("*context.cancelCtx"), expectedFilters).
+			Return(int64(1), nil).Once()
 
 		req := &guardianv1beta1.ListUserAppealsRequest{
 			Statuses:      []string{"active", "pending"},
@@ -129,6 +135,8 @@ func (s *GrpcHandlersSuite) TestListUserAppeals() {
 			ResourceTypes: []string{"test-resource-type"},
 			ResourceUrns:  []string{"test-resource-urn"},
 			OrderBy:       []string{"test-order"},
+			AccountTypes:  []string{"test-account-type"},
+			Q:             "test",
 		}
 		ctx := context.WithValue(context.Background(), authEmailTestContextKey{}, expectedUser)
 		res, err := s.grpcServer.ListUserAppeals(ctx, req)
@@ -156,13 +164,16 @@ func (s *GrpcHandlersSuite) TestListUserAppeals() {
 		s.setup()
 
 		expectedError := errors.New("random error")
-		s.appealService.EXPECT().Find(mock.AnythingOfType("*context.valueCtx"), mock.Anything).
+		s.appealService.EXPECT().Find(mock.AnythingOfType("*context.cancelCtx"), mock.Anything).
 			Return(nil, expectedError).Once()
+		s.appealService.EXPECT().GetAppealsTotalCount(mock.AnythingOfType("*context.cancelCtx"), mock.Anything).
+			Return(int64(0), nil).Once()
 
 		req := &guardianv1beta1.ListUserAppealsRequest{}
 		ctx := context.WithValue(context.Background(), authEmailTestContextKey{}, "test-user")
 		res, err := s.grpcServer.ListUserAppeals(ctx, req)
 
+		fmt.Println(status.Code(err))
 		s.Equal(codes.Internal, status.Code(err))
 		s.Nil(res)
 		s.appealService.AssertExpectations(s.T())
@@ -178,8 +189,10 @@ func (s *GrpcHandlersSuite) TestListUserAppeals() {
 				},
 			},
 		}
-		s.appealService.EXPECT().Find(mock.AnythingOfType("*context.valueCtx"), mock.Anything).
+		s.appealService.EXPECT().Find(mock.AnythingOfType("*context.cancelCtx"), mock.Anything).
 			Return(invalidAppeals, nil).Once()
+		s.appealService.EXPECT().GetAppealsTotalCount(mock.AnythingOfType("*context.cancelCtx"), mock.Anything).
+			Return(int64(1), nil).Once()
 
 		req := &guardianv1beta1.ListUserAppealsRequest{}
 		ctx := context.WithValue(context.Background(), authEmailTestContextKey{}, "test-user")
@@ -288,9 +301,12 @@ func (s *GrpcHandlersSuite) TestListAppeals() {
 					UpdatedAt: timestamppb.New(timeNow),
 				},
 			},
+			Total: 1,
 		}
-		s.appealService.EXPECT().Find(mock.AnythingOfType("*context.emptyCtx"), expectedFilters).
+		s.appealService.EXPECT().Find(mock.AnythingOfType("*context.cancelCtx"), expectedFilters).
 			Return(expectedAppeals, nil).Once()
+		s.appealService.EXPECT().GetAppealsTotalCount(mock.AnythingOfType("*context.cancelCtx"), expectedFilters).
+			Return(int64(1), nil).Once()
 
 		req := &guardianv1beta1.ListAppealsRequest{
 			AccountId:     expectedUser,
@@ -313,8 +329,10 @@ func (s *GrpcHandlersSuite) TestListAppeals() {
 		s.setup()
 
 		expectedError := errors.New("random error")
-		s.appealService.EXPECT().Find(mock.AnythingOfType("*context.emptyCtx"), mock.Anything).
+		s.appealService.EXPECT().Find(mock.AnythingOfType("*context.cancelCtx"), mock.Anything).
 			Return(nil, expectedError).Once()
+		s.appealService.EXPECT().GetAppealsTotalCount(mock.AnythingOfType("*context.cancelCtx"), mock.Anything).
+			Return(int64(0), nil).Once()
 
 		req := &guardianv1beta1.ListAppealsRequest{}
 		res, err := s.grpcServer.ListAppeals(context.Background(), req)
@@ -334,8 +352,10 @@ func (s *GrpcHandlersSuite) TestListAppeals() {
 				},
 			},
 		}
-		s.appealService.EXPECT().Find(mock.AnythingOfType("*context.emptyCtx"), mock.Anything).
+		s.appealService.EXPECT().Find(mock.AnythingOfType("*context.cancelCtx"), mock.Anything).
 			Return(invalidAppeals, nil).Once()
+		s.appealService.EXPECT().GetAppealsTotalCount(mock.AnythingOfType("*context.cancelCtx"), mock.Anything).
+			Return(int64(1), nil).Once()
 
 		req := &guardianv1beta1.ListAppealsRequest{}
 		res, err := s.grpcServer.ListAppeals(context.Background(), req)

api/handler/v1beta1/grant.go

@@ -8,12 +8,14 @@ import (
 	"github.com/goto/guardian/core/grant"
 	"github.com/goto/guardian/core/provider"
 	"github.com/goto/guardian/domain"
+	"golang.org/x/sync/errgroup"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
 
 func (s *GRPCServer) ListGrants(ctx context.Context, req *guardianv1beta1.ListGrantsRequest) (*guardianv1beta1.ListGrantsResponse, error) {
 	filter := domain.ListGrantsFilter{
+		Q:             req.GetQ(),
 		Statuses:      req.GetStatuses(),
 		AccountIDs:    req.GetAccountIds(),
 		AccountTypes:  req.GetAccountTypes(),
@@ -29,18 +31,20 @@ func (s *GRPCServer) ListGrants(ctx context.Context, req *guardianv1beta1.ListGr
 		Size:          int(req.GetSize()),
 		Offset:        int(req.GetOffset()),
 	}
-	grants, err := s.listGrants(ctx, filter)
+	grants, total, err := s.listGrants(ctx, filter)
 	if err != nil {
 		return nil, err
 	}
 
 	return &guardianv1beta1.ListGrantsResponse{
 		Grants: grants,
+		Total:  int32(total),
 	}, nil
 }
 
 func (s *GRPCServer) ListUserGrants(ctx context.Context, req *guardianv1beta1.ListUserGrantsRequest) (*guardianv1beta1.ListUserGrantsResponse, error) {
 	user, err := s.getUser(ctx)
+
 	if err != nil {
 		return nil, status.Error(codes.Unauthenticated, "failed to get metadata: user")
 	}
@@ -60,13 +64,14 @@ func (s *GRPCServer) ListUserGrants(ctx context.Context, req *guardianv1beta1.Li
 		Offset:        int(req.GetOffset()),
 		Owner:         user,
 	}
-	grants, err := s.listGrants(ctx, filter)
+	grants, total, err := s.listGrants(ctx, filter)
 	if err != nil {
 		return nil, err
 	}
 
 	return &guardianv1beta1.ListUserGrantsResponse{
 		Grants: grants,
+		Total:  int32(total),
 	}, nil
 }
 
@@ -171,22 +176,42 @@ func (s *GRPCServer) RevokeGrants(ctx context.Context, req *guardianv1beta1.Revo
 	}, nil
 }
 
-func (s *GRPCServer) listGrants(ctx context.Context, filter domain.ListGrantsFilter) ([]*guardianv1beta1.Grant, error) {
-	grants, err := s.grantService.List(ctx, filter)
-	if err != nil {
-		return nil, status.Errorf(codes.Internal, "failed to list grants: %v", err)
+func (s *GRPCServer) listGrants(ctx context.Context, filter domain.ListGrantsFilter) ([]*guardianv1beta1.Grant, int64, error) {
+	eg, ctx := errgroup.WithContext(ctx)
+	var grants []domain.Grant
+	var total int64
+
+	eg.Go(func() error {
+		grantRecords, err := s.grantService.List(ctx, filter)
+		if err != nil {
+			return status.Errorf(codes.Internal, "failed to get grant list: %s", err)
+		}
+		grants = grantRecords
+		return nil
+	})
+	eg.Go(func() error {
+		totalRecord, err := s.grantService.GetGrantsTotalCount(ctx, filter)
+		if err != nil {
+			return status.Errorf(codes.Internal, "failed to get grant total count: %s", err)
+		}
+		total = totalRecord
+		return nil
+	})
+
+	if err := eg.Wait(); err != nil {
+		return nil, 0, err
 	}
 
 	var grantProtos []*guardianv1beta1.Grant
 	for i, a := range grants {
 		grantProto, err := s.adapter.ToGrantProto(&grants[i])
 		if err != nil {
-			return nil, status.Errorf(codes.Internal, "failed to parse grant %q: %v", a.ID, err)
+			return nil, 0, status.Errorf(codes.Internal, "failed to parse grant %q: %v", a.ID, err)
 		}
 		grantProtos = append(grantProtos, grantProto)
 	}
 
-	return grantProtos, nil
+	return grantProtos, total, nil
 }
 
 func (s *GRPCServer) ImportGrantsFromProvider(ctx context.Context, req *guardianv1beta1.ImportGrantsFromProviderRequest) (*guardianv1beta1.ImportGrantsFromProviderResponse, error) {
@@ -220,3 +245,18 @@ func (s *GRPCServer) ImportGrantsFromProvider(ctx context.Context, req *guardian
 		Grants: grantsProto,
 	}, nil
 }
+
+func (s *GRPCServer) ListUserRoles(ctx context.Context, req *guardianv1beta1.ListUserRolesRequest) (*guardianv1beta1.ListUserRolesResponse, error) {
+	user, err := s.getUser(ctx)
+	if err != nil {
+		return nil, status.Error(codes.Unauthenticated, "failed to get metadata: user")
+	}
+
+	roles, err := s.grantService.ListUserRoles(ctx, user)
+	if err != nil {
+		return nil, err
+	}
+	return &guardianv1beta1.ListUserRolesResponse{
+		Roles: roles,
+	}, nil
+}