feat(approval): search and filter by resource and account type (#391)

* feat(approval): support search query and filter by resource type and account_type

* fix: approval/grant postgres repository filters

---------

Signed-off-by: Kush Sharma <thekushsharma@gmail.com>
Co-authored-by: Chief-Rishab <rishab.jain7209@gmail.com>
Co-authored-by: Kush Sharma <thekushsharma@gmail.com>

Makefile

@@ -3,7 +3,7 @@ COMMIT := $(shell git rev-parse --short HEAD)
 TAG := "$(shell git rev-list --tags --max-count=1)"
 VERSION := "$(shell git describe --tags ${TAG})-next"
 BUILD_DIR=dist
-PROTON_COMMIT := "95140abe54e3c27f0bf4f06bc780a289f41aadf1"
+PROTON_COMMIT := "17305c2660e06ff9c82c1b6130799a703e4e543b"
 
 .PHONY: all build clean test tidy vet proto setup format generate
 

api/handler/v1beta1/activity.go

@@ -66,7 +66,7 @@ func (s *GRPCServer) ListActivities(ctx context.Context, req *guardianv1beta1.Li
 }
 
 func (s *GRPCServer) ImportActivities(ctx context.Context, req *guardianv1beta1.ImportActivitiesRequest) (*guardianv1beta1.ImportActivitiesResponse, error) {
- filter := domain.ImportActivitiesFilter{
+ filter := domain.ListActivitiesFilter{
  ProviderID: req.GetProviderId(),
  ResourceIDs: req.GetResourceIds(),
  AccountIDs: req.GetAccountIds(),

api/handler/v1beta1/appeal.go

@@ -7,6 +7,7 @@ import (
  guardianv1beta1 "github.com/raystack/guardian/api/proto/raystack/guardian/v1beta1"
  "github.com/raystack/guardian/core/appeal"
  "github.com/raystack/guardian/domain"
+ "golang.org/x/sync/errgroup"
  "google.golang.org/grpc/codes"
  "google.golang.org/grpc/status"
 )
@@ -35,40 +36,55 @@ 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()
  }
- appeals, err := s.listAppeals(ctx, filters)
+ if req.GetQ() != "" {
+ filters.Q = req.GetQ()
+ }
+ filters.Offset = int(req.GetOffset())
+ filters.Size = int(req.GetSize())
+
+ 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(),
  ProviderTypes: req.GetProviderTypes(),
  ProviderURNs: req.GetProviderUrns(),
  ResourceTypes: req.GetResourceTypes(),
  ResourceURNs: req.GetResourceUrns(),
+ Size: int(req.GetSize()),
+ 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
 }
 
@@ -106,13 +122,15 @@ func (s *GRPCServer) CreateAppeal(ctx context.Context, req *guardianv1beta1.Crea
 
 func (s *GRPCServer) GetAppeal(ctx context.Context, req *guardianv1beta1.GetAppealRequest) (*guardianv1beta1.GetAppealResponse, error) {
  id := req.GetId()
+
  a, err := s.appealService.GetByID(ctx, id)
  if err != nil {
  if errors.As(err, new(appeal.InvalidError)) || errors.Is(err, appeal.ErrAppealIDEmptyParam) {
  return nil, status.Errorf(codes.InvalidArgument, err.Error())
  }
  return nil, status.Errorf(codes.Internal, "failed to retrieve appeal: %v", err)
  }
+
  if a == nil {
  return nil, status.Errorf(codes.NotFound, "appeal not found: %v", id)
  }
@@ -129,11 +147,13 @@ func (s *GRPCServer) GetAppeal(ctx context.Context, req *guardianv1beta1.GetAppe
 
 func (s *GRPCServer) CancelAppeal(ctx context.Context, req *guardianv1beta1.CancelAppealRequest) (*guardianv1beta1.CancelAppealResponse, error) {
  id := req.GetId()
+
  a, err := s.appealService.Cancel(ctx, id)
  if err != nil {
  if errors.As(err, new(appeal.InvalidError)) || errors.Is(err, appeal.ErrAppealIDEmptyParam) {
  return nil, status.Errorf(codes.InvalidArgument, err.Error())
  }
+
  switch err {
  case appeal.ErrAppealNotFound:
  return nil, status.Errorf(codes.NotFound, "appeal not found: %v", id)
@@ -157,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"
@@ -32,6 +33,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{
  {
@@ -116,9 +119,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"},
@@ -128,6 +134,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)
@@ -155,13 +163,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())
@@ -177,8 +188,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")
@@ -287,9 +300,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,
@@ -312,8 +328,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)
@@ -333,8 +351,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/approval.go

@@ -7,6 +7,7 @@ import (
  guardianv1beta1 "github.com/raystack/guardian/api/proto/raystack/guardian/v1beta1"
  "github.com/raystack/guardian/core/appeal"
  "github.com/raystack/guardian/domain"
+ "golang.org/x/sync/errgroup"
  "google.golang.org/grpc/codes"
  "google.golang.org/grpc/status"
 )
@@ -17,8 +18,11 @@ func (s *GRPCServer) ListUserApprovals(ctx context.Context, req *guardianv1beta1
  return nil, status.Error(codes.Unauthenticated, err.Error())
  }
 
- approvals, err := s.listApprovals(ctx, &domain.ListApprovalsFilter{
+ approvals, total, err := s.listApprovals(ctx, &domain.ListApprovalsFilter{
+ Q: req.GetQ(),
  AccountID: req.GetAccountId(),
+ AccountTypes: req.GetAccountTypes(),
+ ResourceTypes: req.GetResourceTypes(),
  CreatedBy: user,
  Statuses: req.GetStatuses(),
  OrderBy: req.GetOrderBy(),
@@ -32,12 +36,16 @@ func (s *GRPCServer) ListUserApprovals(ctx context.Context, req *guardianv1beta1
 
  return &guardianv1beta1.ListUserApprovalsResponse{
  Approvals: approvals,
+ Total: int32(total),
  }, nil
 }
 
 func (s *GRPCServer) ListApprovals(ctx context.Context, req *guardianv1beta1.ListApprovalsRequest) (*guardianv1beta1.ListApprovalsResponse, error) {
- approvals, err := s.listApprovals(ctx, &domain.ListApprovalsFilter{
+ approvals, total, err := s.listApprovals(ctx, &domain.ListApprovalsFilter{
+ Q: req.GetQ(),
  AccountID: req.GetAccountId(),
+ AccountTypes: req.GetAccountTypes(),
+ ResourceTypes: req.GetResourceTypes(),
  CreatedBy: req.GetCreatedBy(),
  Statuses: req.GetStatuses(),
  OrderBy: req.GetOrderBy(),
@@ -51,6 +59,7 @@ func (s *GRPCServer) ListApprovals(ctx context.Context, req *guardianv1beta1.Lis
 
  return &guardianv1beta1.ListApprovalsResponse{
  Approvals: approvals,
+ Total: int32(total),
  }, nil
 }
 
@@ -150,20 +159,41 @@ func (s *GRPCServer) DeleteApprover(ctx context.Context, req *guardianv1beta1.De
  }, nil
 }
 
-func (s *GRPCServer) listApprovals(ctx context.Context, filters *domain.ListApprovalsFilter) ([]*guardianv1beta1.Approval, error) {
- approvals, err := s.approvalService.ListApprovals(ctx, filters)
- if err != nil {
- return nil, status.Errorf(codes.Internal, "failed to get approval list: %s", err)
+func (s *GRPCServer) listApprovals(ctx context.Context, filters *domain.ListApprovalsFilter) ([]*guardianv1beta1.Approval, int64, error) {
+ eg, ctx := errgroup.WithContext(ctx)
+ var approvals []*domain.Approval
+ var total int64
+
+ eg.Go(func() error {
+ approvalRecords, err := s.approvalService.ListApprovals(ctx, filters)
+ if err != nil {
+ return status.Errorf(codes.Internal, "failed to get approval list: %s", err)
+ }
+ approvals = approvalRecords
+ return nil
+ })
+
+ eg.Go(func() error {
+ totalRecord, err := s.approvalService.GetApprovalsTotalCount(ctx, filters)
+ if err != nil {
+ return status.Errorf(codes.Internal, "failed to get approval list: %v", err)
+ }
+ total = totalRecord
+ return nil
+ })
+
+ if err := eg.Wait(); err != nil {
+ return nil, 0, err
  }
 
  approvalProtos := []*guardianv1beta1.Approval{}
  for _, a := range approvals {
  approvalProto, err := s.adapter.ToApprovalProto(a)
  if err != nil {
- return nil, status.Errorf(codes.Internal, "failed to parse approval: %v: %s", a.ID, err)
+ return nil, 0, status.Errorf(codes.Internal, "failed to parse approval: %v: %s", a.ID, err)
  }
  approvalProtos = append(approvalProtos, approvalProto)
  }
 
- return approvalProtos, nil
+ return approvalProtos, total, nil
 }