SMQ-2966 - Rename domains RetrieveEntity to RetrieveStatus (#2973)

Signed-off-by: Felix Gateru <felix.gateru@gmail.com>

api/grpc/domains/v1/domains.pb.go

@@ -125,7 +125,7 @@ const file_domains_v1_domains_proto_rawDesc = "" +
 	"\x02id\x18\x01 \x01(\tR\x02id2\x83\x02\n" +
 	"\x0eDomainsService\x12O\n" +
 	"\x15DeleteUserFromDomains\x12\x19.domains.v1.DeleteUserReq\x1a\x19.domains.v1.DeleteUserRes\"\x00\x12N\n" +
-	"\x0eRetrieveEntity\x12\x1c.common.v1.RetrieveEntityReq\x1a\x1c.common.v1.RetrieveEntityRes\"\x00\x12P\n" +
+	"\x0eRetrieveStatus\x12\x1c.common.v1.RetrieveEntityReq\x1a\x1c.common.v1.RetrieveEntityRes\"\x00\x12P\n" +
 	"\x0fRetrieveByRoute\x12\x1d.common.v1.RetrieveByRouteReq\x1a\x1c.common.v1.RetrieveEntityRes\"\x00B5Z3github.com/absmach/supermq/internal/grpc/domains/v1b\x06proto3"
 
 var (
@@ -150,10 +150,10 @@ var file_domains_v1_domains_proto_goTypes = []any{
 }
 var file_domains_v1_domains_proto_depIdxs = []int32{
 	1, // 0: domains.v1.DomainsService.DeleteUserFromDomains:input_type -> domains.v1.DeleteUserReq
-	2, // 1: domains.v1.DomainsService.RetrieveEntity:input_type -> common.v1.RetrieveEntityReq
+	2, // 1: domains.v1.DomainsService.RetrieveStatus:input_type -> common.v1.RetrieveEntityReq
 	3, // 2: domains.v1.DomainsService.RetrieveByRoute:input_type -> common.v1.RetrieveByRouteReq
 	0, // 3: domains.v1.DomainsService.DeleteUserFromDomains:output_type -> domains.v1.DeleteUserRes
-	4, // 4: domains.v1.DomainsService.RetrieveEntity:output_type -> common.v1.RetrieveEntityRes
+	4, // 4: domains.v1.DomainsService.RetrieveStatus:output_type -> common.v1.RetrieveEntityRes
 	4, // 5: domains.v1.DomainsService.RetrieveByRoute:output_type -> common.v1.RetrieveEntityRes
 	3, // [3:6] is the sub-list for method output_type
 	0, // [0:3] is the sub-list for method input_type

api/grpc/domains/v1/domains_grpc.pb.go

@@ -24,7 +24,7 @@ const _ = grpc.SupportPackageIsVersion9
 
 const (
 	DomainsService_DeleteUserFromDomains_FullMethodName = "/domains.v1.DomainsService/DeleteUserFromDomains"
-	DomainsService_RetrieveEntity_FullMethodName        = "/domains.v1.DomainsService/RetrieveEntity"
+	DomainsService_RetrieveStatus_FullMethodName        = "/domains.v1.DomainsService/RetrieveStatus"
 	DomainsService_RetrieveByRoute_FullMethodName       = "/domains.v1.DomainsService/RetrieveByRoute"
 )
 
@@ -36,7 +36,7 @@ const (
 // domains functionalities for SuperMQ services.
 type DomainsServiceClient interface {
 	DeleteUserFromDomains(ctx context.Context, in *DeleteUserReq, opts ...grpc.CallOption) (*DeleteUserRes, error)
-	RetrieveEntity(ctx context.Context, in *v1.RetrieveEntityReq, opts ...grpc.CallOption) (*v1.RetrieveEntityRes, error)
+	RetrieveStatus(ctx context.Context, in *v1.RetrieveEntityReq, opts ...grpc.CallOption) (*v1.RetrieveEntityRes, error)
 	RetrieveByRoute(ctx context.Context, in *v1.RetrieveByRouteReq, opts ...grpc.CallOption) (*v1.RetrieveEntityRes, error)
 }
 
@@ -58,10 +58,10 @@ func (c *domainsServiceClient) DeleteUserFromDomains(ctx context.Context, in *De
 	return out, nil
 }
 
-func (c *domainsServiceClient) RetrieveEntity(ctx context.Context, in *v1.RetrieveEntityReq, opts ...grpc.CallOption) (*v1.RetrieveEntityRes, error) {
+func (c *domainsServiceClient) RetrieveStatus(ctx context.Context, in *v1.RetrieveEntityReq, opts ...grpc.CallOption) (*v1.RetrieveEntityRes, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(v1.RetrieveEntityRes)
-	err := c.cc.Invoke(ctx, DomainsService_RetrieveEntity_FullMethodName, in, out, cOpts...)
+	err := c.cc.Invoke(ctx, DomainsService_RetrieveStatus_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -86,7 +86,7 @@ func (c *domainsServiceClient) RetrieveByRoute(ctx context.Context, in *v1.Retri
 // domains functionalities for SuperMQ services.
 type DomainsServiceServer interface {
 	DeleteUserFromDomains(context.Context, *DeleteUserReq) (*DeleteUserRes, error)
-	RetrieveEntity(context.Context, *v1.RetrieveEntityReq) (*v1.RetrieveEntityRes, error)
+	RetrieveStatus(context.Context, *v1.RetrieveEntityReq) (*v1.RetrieveEntityRes, error)
 	RetrieveByRoute(context.Context, *v1.RetrieveByRouteReq) (*v1.RetrieveEntityRes, error)
 	mustEmbedUnimplementedDomainsServiceServer()
 }
@@ -101,8 +101,8 @@ type UnimplementedDomainsServiceServer struct{}
 func (UnimplementedDomainsServiceServer) DeleteUserFromDomains(context.Context, *DeleteUserReq) (*DeleteUserRes, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method DeleteUserFromDomains not implemented")
 }
-func (UnimplementedDomainsServiceServer) RetrieveEntity(context.Context, *v1.RetrieveEntityReq) (*v1.RetrieveEntityRes, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method RetrieveEntity not implemented")
+func (UnimplementedDomainsServiceServer) RetrieveStatus(context.Context, *v1.RetrieveEntityReq) (*v1.RetrieveEntityRes, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method RetrieveStatus not implemented")
 }
 func (UnimplementedDomainsServiceServer) RetrieveByRoute(context.Context, *v1.RetrieveByRouteReq) (*v1.RetrieveEntityRes, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method RetrieveByRoute not implemented")
@@ -146,20 +146,20 @@ func _DomainsService_DeleteUserFromDomains_Handler(srv interface{}, ctx context.
 	return interceptor(ctx, in, info, handler)
 }
 
-func _DomainsService_RetrieveEntity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+func _DomainsService_RetrieveStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(v1.RetrieveEntityReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(DomainsServiceServer).RetrieveEntity(ctx, in)
+		return srv.(DomainsServiceServer).RetrieveStatus(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: DomainsService_RetrieveEntity_FullMethodName,
+		FullMethod: DomainsService_RetrieveStatus_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(DomainsServiceServer).RetrieveEntity(ctx, req.(*v1.RetrieveEntityReq))
+		return srv.(DomainsServiceServer).RetrieveStatus(ctx, req.(*v1.RetrieveEntityReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -194,8 +194,8 @@ var DomainsService_ServiceDesc = grpc.ServiceDesc{
 			Handler:    _DomainsService_DeleteUserFromDomains_Handler,
 		},
 		{
-			MethodName: "RetrieveEntity",
-			Handler:    _DomainsService_RetrieveEntity_Handler,
+			MethodName: "RetrieveStatus",
+			Handler:    _DomainsService_RetrieveStatus_Handler,
 		},
 		{
 			MethodName: "RetrieveByRoute",

channels/private/service.go

@@ -40,11 +40,11 @@ func New(repo channels.Repository, cache channels.Cache, evaluator policies.Eval
 }
 
 func (svc service) Authorize(ctx context.Context, req channels.AuthzReq) error {
-	d, err := svc.domains.RetrieveEntity(ctx, req.DomainID)
+	status, err := svc.domains.RetrieveStatus(ctx, req.DomainID)
 	if err != nil {
 		return errors.Wrap(svcerr.ErrAuthorization, err)
 	}
-	if d.Status != dom.EnabledStatus {
+	if status != dom.EnabledStatus {
 		return errors.Wrap(svcerr.ErrAuthorization, errDisabledDomain)
 	}
 	switch req.ClientType {

domains/api/grpc/client.go

@@ -21,7 +21,7 @@ var _ grpcDomainsV1.DomainsServiceClient = (*domainsGrpcClient)(nil)
 
 type domainsGrpcClient struct {
 	deleteUserFromDomains endpoint.Endpoint
-	retrieveEntity        endpoint.Endpoint
+	retrieveStatus        endpoint.Endpoint
 	retrieveByRoute       endpoint.Endpoint
 	timeout               time.Duration
 }
@@ -37,12 +37,12 @@ func NewDomainsClient(conn *grpc.ClientConn, timeout time.Duration) grpcDomainsV
 			decodeDeleteUserResponse,
 			grpcDomainsV1.DeleteUserRes{},
 		).Endpoint(),
-		retrieveEntity: kitgrpc.NewClient(
+		retrieveStatus: kitgrpc.NewClient(
 			conn,
 			domainsSvcName,
-			"RetrieveEntity",
-			encodeRetrieveEntityRequest,
-			decodeRetrieveEntityResponse,
+			"RetrieveStatus",
+			encodeRetrieveStatusRequest,
+			decodeRetrieveStatusResponse,
 			grpcCommonV1.RetrieveEntityRes{},
 		).Endpoint(),
 		retrieveByRoute: kitgrpc.NewClient(
@@ -84,33 +84,32 @@ func encodeDeleteUserRequest(_ context.Context, grpcReq interface{}) (interface{
 	}, nil
 }
 
-func (client domainsGrpcClient) RetrieveEntity(ctx context.Context, in *grpcCommonV1.RetrieveEntityReq, opts ...grpc.CallOption) (*grpcCommonV1.RetrieveEntityRes, error) {
+func (client domainsGrpcClient) RetrieveStatus(ctx context.Context, in *grpcCommonV1.RetrieveEntityReq, opts ...grpc.CallOption) (*grpcCommonV1.RetrieveEntityRes, error) {
 	ctx, cancel := context.WithTimeout(ctx, client.timeout)
 	defer cancel()
 
-	res, err := client.retrieveEntity(ctx, retrieveEntityReq{
+	res, err := client.retrieveStatus(ctx, retrieveStatusReq{
 		ID: in.GetId(),
 	})
 	if err != nil {
 		return &grpcCommonV1.RetrieveEntityRes{}, grpcapi.DecodeError(err)
 	}
 
-	rdsr := res.(retrieveEntityRes)
+	rdsr := res.(retrieveStatusRes)
 	return &grpcCommonV1.RetrieveEntityRes{
 		Entity: &grpcCommonV1.EntityBasic{
-			Id:     rdsr.id,
 			Status: uint32(rdsr.status),
 		},
 	}, nil
 }
 
-func decodeRetrieveEntityResponse(_ context.Context, grpcRes interface{}) (interface{}, error) {
+func decodeRetrieveStatusResponse(_ context.Context, grpcRes interface{}) (interface{}, error) {
 	res := grpcRes.(*grpcCommonV1.RetrieveEntityRes)
-	return retrieveEntityRes{id: res.Entity.GetId(), status: uint8(res.Entity.GetStatus())}, nil
+	return retrieveStatusRes{status: uint8(res.Entity.GetStatus())}, nil
 }
 
-func encodeRetrieveEntityRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
-	req := grpcReq.(retrieveEntityReq)
+func encodeRetrieveStatusRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
+	req := grpcReq.(retrieveStatusReq)
 	return &grpcCommonV1.RetrieveEntityReq{
 		Id: req.ID,
 	}, nil

domains/api/grpc/endpoint.go

@@ -25,21 +25,20 @@ func deleteUserFromDomainsEndpoint(svc domains.Service) endpoint.Endpoint {
 	}
 }
 
-func retrieveEntityEndpoint(svc domains.Service) endpoint.Endpoint {
+func retrieveStatusEndpoint(svc domains.Service) endpoint.Endpoint {
 	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(retrieveEntityReq)
+		req := request.(retrieveStatusReq)
 		if err := req.validate(); err != nil {
-			return retrieveEntityRes{}, err
+			return retrieveStatusRes{}, err
 		}
 
-		dom, err := svc.RetrieveEntity(ctx, req.ID)
+		status, err := svc.RetrieveStatus(ctx, req.ID)
 		if err != nil {
-			return retrieveEntityRes{}, err
+			return retrieveStatusRes{}, err
 		}
 
-		return retrieveEntityRes{
-			id:     dom.ID,
-			status: uint8(dom.Status),
+		return retrieveStatusRes{
+			status: uint8(status),
 		}, nil
 	}
 }

domains/api/grpc/endpoint_test.go

@@ -105,62 +105,57 @@ func TestDeleteUserFromDomains(t *testing.T) {
 	}
 }
 
-func TestRetrieveEntity(t *testing.T) {
+func TestRetrieveStatus(t *testing.T) {
 	conn, err := grpc.NewClient(authAddr, grpc.WithTransportCredentials(insecure.NewCredentials()))
 	assert.Nil(t, err, fmt.Sprintf("Unexpected error creating client connection %s", err))
 	grpcClient := grpcapi.NewDomainsClient(conn, time.Second)
 
-	dom := domains.Domain{
-		ID:     id,
-		Status: domains.EnabledStatus,
-	}
 	cases := []struct {
 		desc        string
 		token       string
 		retrieveReq *grpcCommonV1.RetrieveEntityReq
-		svcRes      domains.Domain
+		svcRes      domains.Status
 		svcErr      error
 		retrieveRes *grpcCommonV1.RetrieveEntityRes
 		err         error
 	}{
 		{
-			desc:  "retrieve entity with valid req",
+			desc:  "retrieve status with valid req",
 			token: validToken,
 			retrieveReq: &grpcCommonV1.RetrieveEntityReq{
 				Id: id,
 			},
-			svcRes: dom,
+			svcRes: domains.EnabledStatus,
 			retrieveRes: &grpcCommonV1.RetrieveEntityRes{
 				Entity: &grpcCommonV1.EntityBasic{
-					Id:     id,
 					Status: uint32(domains.EnabledStatus),
 				},
 			},
 			err: nil,
 		},
 		{
-			desc: "retrieve entity with empty id",
+			desc: "retrieve status with empty id",
 			retrieveReq: &grpcCommonV1.RetrieveEntityReq{
 				Id: "",
 			},
-			svcRes:      domains.Domain{},
+			svcRes:      domains.AllStatus,
 			retrieveRes: &grpcCommonV1.RetrieveEntityRes{},
 			err:         apiutil.ErrMissingID,
 		},
 		{
-			desc: "retrieve entity with invalid id",
+			desc: "retrieve status with invalid id",
 			retrieveReq: &grpcCommonV1.RetrieveEntityReq{
 				Id: "invalid",
 			},
-			svcRes:      domains.Domain{},
+			svcRes:      domains.AllStatus,
 			svcErr:      svcerr.ErrNotFound,
 			retrieveRes: &grpcCommonV1.RetrieveEntityRes{},
 			err:         svcerr.ErrNotFound,
 		},
 	}
 	for _, tc := range cases {
-		svcCall := svc.On("RetrieveEntity", mock.Anything, tc.retrieveReq.Id).Return(tc.svcRes, tc.svcErr)
-		dpr, err := grpcClient.RetrieveEntity(context.Background(), tc.retrieveReq)
+		svcCall := svc.On("RetrieveStatus", mock.Anything, tc.retrieveReq.Id).Return(tc.svcRes, tc.svcErr)
+		dpr, err := grpcClient.RetrieveStatus(context.Background(), tc.retrieveReq)
 		assert.Equal(t, tc.retrieveRes.Entity, dpr.Entity, fmt.Sprintf("%s: expected %v got %v", tc.desc, tc.retrieveRes.Entity, dpr.Entity))
 		assert.True(t, errors.Contains(err, tc.err), fmt.Sprintf("%s: expected %s got %s\n", tc.desc, tc.err, err))
 		svcCall.Unset()

domains/api/grpc/requests.go

@@ -19,11 +19,11 @@ func (req deleteUserPoliciesReq) validate() error {
 	return nil
 }
 
-type retrieveEntityReq struct {
+type retrieveStatusReq struct {
 	ID string
 }
 
-func (req retrieveEntityReq) validate() error {
+func (req retrieveStatusReq) validate() error {
 	if req.ID == "" {
 		return apiutil.ErrMissingID
 	}

domains/api/grpc/responses.go

@@ -11,3 +11,7 @@ type retrieveEntityRes struct {
 	id     string
 	status uint8
 }
+
+type retrieveStatusRes struct {
+	status uint8
+}

domains/api/grpc/server.go

@@ -18,7 +18,7 @@ var _ grpcDomainsV1.DomainsServiceServer = (*domainsGrpcServer)(nil)
 type domainsGrpcServer struct {
 	grpcDomainsV1.UnimplementedDomainsServiceServer
 	deleteUserFromDomains kitgrpc.Handler
-	retrieveEntity        kitgrpc.Handler
+	retrieveStatus        kitgrpc.Handler
 	retrieveByRoute       kitgrpc.Handler
 }
 
@@ -29,10 +29,10 @@ func NewDomainsServer(svc domains.Service) grpcDomainsV1.DomainsServiceServer {
 			decodeDeleteUserRequest,
 			encodeDeleteUserResponse,
 		),
-		retrieveEntity: kitgrpc.NewServer(
-			retrieveEntityEndpoint(svc),
-			decodeRetrieveEntityRequest,
-			encodeRetrieveEntityResponse,
+		retrieveStatus: kitgrpc.NewServer(
+			retrieveStatusEndpoint(svc),
+			decodeRetrieveStatusRequest,
+			encodeRetrieveStatusResponse,
 		),
 		retrieveByRoute: kitgrpc.NewServer(
 			retrieveByRouteEndpoint(svc),
@@ -62,27 +62,26 @@ func (s *domainsGrpcServer) DeleteUserFromDomains(ctx context.Context, req *grpc
 	return res.(*grpcDomainsV1.DeleteUserRes), nil
 }
 
-func decodeRetrieveEntityRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
+func decodeRetrieveStatusRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
 	req := grpcReq.(*grpcCommonV1.RetrieveEntityReq)
 
-	return retrieveEntityReq{
+	return retrieveStatusReq{
 		ID: req.GetId(),
 	}, nil
 }
 
-func encodeRetrieveEntityResponse(_ context.Context, grpcRes interface{}) (interface{}, error) {
-	res := grpcRes.(retrieveEntityRes)
+func encodeRetrieveStatusResponse(_ context.Context, grpcRes interface{}) (interface{}, error) {
+	res := grpcRes.(retrieveStatusRes)
 
 	return &grpcCommonV1.RetrieveEntityRes{
 		Entity: &grpcCommonV1.EntityBasic{
-			Id:     res.id,
 			Status: uint32(res.status),
 		},
 	}, nil
 }
 
-func (s *domainsGrpcServer) RetrieveEntity(ctx context.Context, req *grpcCommonV1.RetrieveEntityReq) (*grpcCommonV1.RetrieveEntityRes, error) {
-	_, res, err := s.retrieveEntity.ServeGRPC(ctx, req)
+func (s *domainsGrpcServer) RetrieveStatus(ctx context.Context, req *grpcCommonV1.RetrieveEntityReq) (*grpcCommonV1.RetrieveEntityRes, error) {
+	_, res, err := s.retrieveStatus.ServeGRPC(ctx, req)
 	if err != nil {
 		return nil, grpcapi.EncodeError(err)
 	}

domains/mocks/domains_client.go

@@ -209,8 +209,8 @@ func (_c *DomainsServiceClient_RetrieveByRoute_Call) RunAndReturn(run func(ctx c
 	return _c
 }
 
-// RetrieveEntity provides a mock function for the type DomainsServiceClient
-func (_mock *DomainsServiceClient) RetrieveEntity(ctx context.Context, in *v10.RetrieveEntityReq, opts ...grpc.CallOption) (*v10.RetrieveEntityRes, error) {
+// RetrieveStatus provides a mock function for the type DomainsServiceClient
+func (_mock *DomainsServiceClient) RetrieveStatus(ctx context.Context, in *v10.RetrieveEntityReq, opts ...grpc.CallOption) (*v10.RetrieveEntityRes, error) {
 	var tmpRet mock.Arguments
 	if len(opts) > 0 {
 		tmpRet = _mock.Called(ctx, in, opts)
@@ -220,7 +220,7 @@ func (_mock *DomainsServiceClient) RetrieveEntity(ctx context.Context, in *v10.R
 	ret := tmpRet
 
 	if len(ret) == 0 {
-		panic("no return value specified for RetrieveEntity")
+		panic("no return value specified for RetrieveStatus")
 	}
 
 	var r0 *v10.RetrieveEntityRes
@@ -243,21 +243,21 @@ func (_mock *DomainsServiceClient) RetrieveEntity(ctx context.Context, in *v10.R
 	return r0, r1
 }
 
-// DomainsServiceClient_RetrieveEntity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveEntity'
-type DomainsServiceClient_RetrieveEntity_Call struct {
+// DomainsServiceClient_RetrieveStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveStatus'
+type DomainsServiceClient_RetrieveStatus_Call struct {
 	*mock.Call
 }
 
-// RetrieveEntity is a helper method to define mock.On call
+// RetrieveStatus is a helper method to define mock.On call
 //   - ctx context.Context
 //   - in *v10.RetrieveEntityReq
 //   - opts ...grpc.CallOption
-func (_e *DomainsServiceClient_Expecter) RetrieveEntity(ctx interface{}, in interface{}, opts ...interface{}) *DomainsServiceClient_RetrieveEntity_Call {
-	return &DomainsServiceClient_RetrieveEntity_Call{Call: _e.mock.On("RetrieveEntity",
+func (_e *DomainsServiceClient_Expecter) RetrieveStatus(ctx interface{}, in interface{}, opts ...interface{}) *DomainsServiceClient_RetrieveStatus_Call {
+	return &DomainsServiceClient_RetrieveStatus_Call{Call: _e.mock.On("RetrieveStatus",
 		append([]interface{}{ctx, in}, opts...)...)}
 }
 
-func (_c *DomainsServiceClient_RetrieveEntity_Call) Run(run func(ctx context.Context, in *v10.RetrieveEntityReq, opts ...grpc.CallOption)) *DomainsServiceClient_RetrieveEntity_Call {
+func (_c *DomainsServiceClient_RetrieveStatus_Call) Run(run func(ctx context.Context, in *v10.RetrieveEntityReq, opts ...grpc.CallOption)) *DomainsServiceClient_RetrieveStatus_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
@@ -282,12 +282,12 @@ func (_c *DomainsServiceClient_RetrieveEntity_Call) Run(run func(ctx context.Con
 	return _c
 }
 
-func (_c *DomainsServiceClient_RetrieveEntity_Call) Return(retrieveEntityRes *v10.RetrieveEntityRes, err error) *DomainsServiceClient_RetrieveEntity_Call {
+func (_c *DomainsServiceClient_RetrieveStatus_Call) Return(retrieveEntityRes *v10.RetrieveEntityRes, err error) *DomainsServiceClient_RetrieveStatus_Call {
 	_c.Call.Return(retrieveEntityRes, err)
 	return _c
 }
 
-func (_c *DomainsServiceClient_RetrieveEntity_Call) RunAndReturn(run func(ctx context.Context, in *v10.RetrieveEntityReq, opts ...grpc.CallOption) (*v10.RetrieveEntityRes, error)) *DomainsServiceClient_RetrieveEntity_Call {
+func (_c *DomainsServiceClient_RetrieveStatus_Call) RunAndReturn(run func(ctx context.Context, in *v10.RetrieveEntityReq, opts ...grpc.CallOption) (*v10.RetrieveEntityRes, error)) *DomainsServiceClient_RetrieveStatus_Call {
 	_c.Call.Return(run)
 	return _c
 }

domains/private/mocks/service.go

@@ -164,23 +164,23 @@ func (_c *Service_RetrieveByRoute_Call) RunAndReturn(run func(ctx context.Contex
 	return _c
 }
 
-// RetrieveEntity provides a mock function for the type Service
-func (_mock *Service) RetrieveEntity(ctx context.Context, id string) (domains.Domain, error) {
+// RetrieveStatus provides a mock function for the type Service
+func (_mock *Service) RetrieveStatus(ctx context.Context, id string) (domains.Status, error) {
 	ret := _mock.Called(ctx, id)
 
 	if len(ret) == 0 {
-		panic("no return value specified for RetrieveEntity")
+		panic("no return value specified for RetrieveStatus")
 	}
 
-	var r0 domains.Domain
+	var r0 domains.Status
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (domains.Domain, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string) (domains.Status, error)); ok {
 		return returnFunc(ctx, id)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, string) domains.Domain); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string) domains.Status); ok {
 		r0 = returnFunc(ctx, id)
 	} else {
-		r0 = ret.Get(0).(domains.Domain)
+		r0 = ret.Get(0).(domains.Status)
 	}
 	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
 		r1 = returnFunc(ctx, id)
@@ -190,19 +190,19 @@ func (_mock *Service) RetrieveEntity(ctx context.Context, id string) (domains.Do
 	return r0, r1
 }
 
-// Service_RetrieveEntity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveEntity'
-type Service_RetrieveEntity_Call struct {
+// Service_RetrieveStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveStatus'
+type Service_RetrieveStatus_Call struct {
 	*mock.Call
 }
 
-// RetrieveEntity is a helper method to define mock.On call
+// RetrieveStatus is a helper method to define mock.On call
 //   - ctx context.Context
 //   - id string
-func (_e *Service_Expecter) RetrieveEntity(ctx interface{}, id interface{}) *Service_RetrieveEntity_Call {
-	return &Service_RetrieveEntity_Call{Call: _e.mock.On("RetrieveEntity", ctx, id)}
+func (_e *Service_Expecter) RetrieveStatus(ctx interface{}, id interface{}) *Service_RetrieveStatus_Call {
+	return &Service_RetrieveStatus_Call{Call: _e.mock.On("RetrieveStatus", ctx, id)}
 }
 
-func (_c *Service_RetrieveEntity_Call) Run(run func(ctx context.Context, id string)) *Service_RetrieveEntity_Call {
+func (_c *Service_RetrieveStatus_Call) Run(run func(ctx context.Context, id string)) *Service_RetrieveStatus_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
@@ -220,12 +220,12 @@ func (_c *Service_RetrieveEntity_Call) Run(run func(ctx context.Context, id stri
 	return _c
 }
 
-func (_c *Service_RetrieveEntity_Call) Return(domain domains.Domain, err error) *Service_RetrieveEntity_Call {
-	_c.Call.Return(domain, err)
+func (_c *Service_RetrieveStatus_Call) Return(status domains.Status, err error) *Service_RetrieveStatus_Call {
+	_c.Call.Return(status, err)
 	return _c
 }
 
-func (_c *Service_RetrieveEntity_Call) RunAndReturn(run func(ctx context.Context, id string) (domains.Domain, error)) *Service_RetrieveEntity_Call {
+func (_c *Service_RetrieveStatus_Call) RunAndReturn(run func(ctx context.Context, id string) (domains.Status, error)) *Service_RetrieveStatus_Call {
 	_c.Call.Return(run)
 	return _c
 }

domains/private/service.go

@@ -14,7 +14,7 @@ import (
 const defLimit = 100
 
 type Service interface {
-	RetrieveEntity(ctx context.Context, id string) (domains.Domain, error)
+	RetrieveStatus(ctx context.Context, id string) (domains.Status, error)
 	DeleteUserFromDomains(ctx context.Context, id string) error
 	RetrieveByRoute(ctx context.Context, route string) (domains.Domain, error)
 }
@@ -33,21 +33,21 @@ type service struct {
 	cache domains.Cache
 }
 
-func (svc service) RetrieveEntity(ctx context.Context, id string) (domains.Domain, error) {
+func (svc service) RetrieveStatus(ctx context.Context, id string) (domains.Status, error) {
 	status, err := svc.cache.Status(ctx, id)
 	if err == nil {
-		return domains.Domain{ID: id, Status: status}, nil
+		return status, nil
 	}
 	dom, err := svc.repo.RetrieveDomainByID(ctx, id)
 	if err != nil {
-		return domains.Domain{}, errors.Wrap(svcerr.ErrViewEntity, err)
+		return domains.AllStatus, errors.Wrap(svcerr.ErrViewEntity, err)
 	}
 	status = dom.Status
 	if err := svc.cache.SaveStatus(ctx, id, status); err != nil {
-		return domains.Domain{}, errors.Wrap(svcerr.ErrUpdateEntity, err)
+		return domains.AllStatus, errors.Wrap(svcerr.ErrUpdateEntity, err)
 	}
 
-	return domains.Domain{ID: dom.ID, Status: dom.Status}, nil
+	return dom.Status, nil
 }
 
 func (svc service) DeleteUserFromDomains(ctx context.Context, id string) (err error) {

internal/proto/domains/v1/domains.proto

@@ -15,7 +15,7 @@ option go_package = "github.com/absmach/supermq/internal/grpc/domains/v1";
 service DomainsService {
   rpc DeleteUserFromDomains(DeleteUserReq)
     returns (DeleteUserRes) {}
-  rpc RetrieveEntity(common.v1.RetrieveEntityReq) 
+  rpc RetrieveStatus(common.v1.RetrieveEntityReq) 
     returns (common.v1.RetrieveEntityRes) {}
   rpc RetrieveByRoute(common.v1.RetrieveByRouteReq)
     returns (common.v1.RetrieveEntityRes) {}

pkg/authz/authsvc/authz.go

@@ -82,12 +82,12 @@ func (a authorization) Authorize(ctx context.Context, pr authz.PolicyReq) error
 }
 
 func (a authorization) checkDomain(ctx context.Context, subjectType, subject, domainID string) error {
-	dom, err := a.domains.RetrieveEntity(ctx, domainID)
+	status, err := a.domains.RetrieveStatus(ctx, domainID)
 	if err != nil {
 		return errors.Wrap(svcerr.ErrViewEntity, err)
 	}
 
-	switch dom.Status {
+	switch status {
 	case domains.FreezeStatus:
 		_, err := a.authSvcClient.Authorize(ctx, &grpcAuthV1.AuthZReq{
 			Subject:     subject,

pkg/domains/authz.go

@@ -10,5 +10,5 @@ import (
 )
 
 type Authorization interface {
-	RetrieveEntity(ctx context.Context, id string) (domains.Domain, error)
+	RetrieveStatus(ctx context.Context, id string) (domains.Status, error)
 }

pkg/domains/grpcclient/authz.go

@@ -28,17 +28,14 @@ func NewAuthorization(ctx context.Context, cfg grpcclient.Config) (pkgDomains.Au
 	return authorization{domainsSvcClient: domainsClient}, domainsClient, domainsHandler, nil
 }
 
-func (a authorization) RetrieveEntity(ctx context.Context, id string) (domains.Domain, error) {
+func (a authorization) RetrieveStatus(ctx context.Context, id string) (domains.Status, error) {
 	req := grpcCommonV1.RetrieveEntityReq{
 		Id: id,
 	}
-	res, err := a.domainsSvcClient.RetrieveEntity(ctx, &req)
+	res, err := a.domainsSvcClient.RetrieveStatus(ctx, &req)
 	if err != nil {
-		return domains.Domain{}, err
+		return domains.AllStatus, err
 	}
 
-	return domains.Domain{
-		ID:     res.Entity.GetId(),
-		Status: domains.Status(res.Entity.GetStatus()),
-	}, nil
+	return domains.Status(res.Entity.GetStatus()), nil
 }

pkg/domains/psvc/authz.go

@@ -25,10 +25,11 @@ func NewAuthorization(psvc private.Service) pkgDomains.Authorization {
 	}
 }
 
-func (a authorization) RetrieveEntity(ctx context.Context, id string) (domains.Domain, error) {
-	dom, err := a.psvc.RetrieveEntity(ctx, id)
+func (a authorization) RetrieveStatus(ctx context.Context, id string) (domains.Status, error) {
+	status, err := a.psvc.RetrieveStatus(ctx, id)
 	if err != nil {
-		return domains.Domain{}, errors.Wrap(svcerr.ErrViewEntity, err)
+		return domains.AllStatus, errors.Wrap(svcerr.ErrViewEntity, err)
 	}
-	return dom, nil
+
+	return status, nil
 }