SMQ-2967- Rename RetrieveByRoute method to RetrieveIDByRoute (#2972)

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

api/grpc/channels/v1/channels.pb.go

@@ -327,13 +327,13 @@ const file_channels_v1_channels_proto_rawDesc = "" +
 	"\bAuthzRes\x12\x1e\n" +
 	"\n" +
 	"authorized\x18\x01 \x01(\bR\n" +
-	"authorized2\xdd\x03\n" +
+	"authorized2\xe1\x03\n" +
 	"\x0fChannelsService\x12;\n" +
 	"\tAuthorize\x12\x15.channels.v1.AuthzReq\x1a\x15.channels.v1.AuthzRes\"\x00\x12m\n" +
 	"\x17RemoveClientConnections\x12'.channels.v1.RemoveClientConnectionsReq\x1a'.channels.v1.RemoveClientConnectionsRes\"\x00\x12|\n" +
 	"\x1cUnsetParentGroupFromChannels\x12,.channels.v1.UnsetParentGroupFromChannelsReq\x1a,.channels.v1.UnsetParentGroupFromChannelsRes\"\x00\x12N\n" +
-	"\x0eRetrieveEntity\x12\x1c.common.v1.RetrieveEntityReq\x1a\x1c.common.v1.RetrieveEntityRes\"\x00\x12P\n" +
-	"\x0fRetrieveByRoute\x12\x1d.common.v1.RetrieveByRouteReq\x1a\x1c.common.v1.RetrieveEntityRes\"\x00B1Z/github.com/absmach/supermq/api/grpc/channels/v1b\x06proto3"
+	"\x0eRetrieveEntity\x12\x1c.common.v1.RetrieveEntityReq\x1a\x1c.common.v1.RetrieveEntityRes\"\x00\x12T\n" +
+	"\x11RetrieveIDByRoute\x12\x1f.common.v1.RetrieveIDByRouteReq\x1a\x1c.common.v1.RetrieveEntityRes\"\x00B1Z/github.com/absmach/supermq/api/grpc/channels/v1b\x06proto3"
 
 var (
 	file_channels_v1_channels_proto_rawDescOnce sync.Once
@@ -356,7 +356,7 @@ var file_channels_v1_channels_proto_goTypes = []any{
 	(*AuthzReq)(nil),                        // 4: channels.v1.AuthzReq
 	(*AuthzRes)(nil),                        // 5: channels.v1.AuthzRes
 	(*v1.RetrieveEntityReq)(nil),            // 6: common.v1.RetrieveEntityReq
-	(*v1.RetrieveByRouteReq)(nil),           // 7: common.v1.RetrieveByRouteReq
+	(*v1.RetrieveIDByRouteReq)(nil),         // 7: common.v1.RetrieveIDByRouteReq
 	(*v1.RetrieveEntityRes)(nil),            // 8: common.v1.RetrieveEntityRes
 }
 var file_channels_v1_channels_proto_depIdxs = []int32{
@@ -364,12 +364,12 @@ var file_channels_v1_channels_proto_depIdxs = []int32{
 	0, // 1: channels.v1.ChannelsService.RemoveClientConnections:input_type -> channels.v1.RemoveClientConnectionsReq
 	2, // 2: channels.v1.ChannelsService.UnsetParentGroupFromChannels:input_type -> channels.v1.UnsetParentGroupFromChannelsReq
 	6, // 3: channels.v1.ChannelsService.RetrieveEntity:input_type -> common.v1.RetrieveEntityReq
-	7, // 4: channels.v1.ChannelsService.RetrieveByRoute:input_type -> common.v1.RetrieveByRouteReq
+	7, // 4: channels.v1.ChannelsService.RetrieveIDByRoute:input_type -> common.v1.RetrieveIDByRouteReq
 	5, // 5: channels.v1.ChannelsService.Authorize:output_type -> channels.v1.AuthzRes
 	1, // 6: channels.v1.ChannelsService.RemoveClientConnections:output_type -> channels.v1.RemoveClientConnectionsRes
 	3, // 7: channels.v1.ChannelsService.UnsetParentGroupFromChannels:output_type -> channels.v1.UnsetParentGroupFromChannelsRes
 	8, // 8: channels.v1.ChannelsService.RetrieveEntity:output_type -> common.v1.RetrieveEntityRes
-	8, // 9: channels.v1.ChannelsService.RetrieveByRoute:output_type -> common.v1.RetrieveEntityRes
+	8, // 9: channels.v1.ChannelsService.RetrieveIDByRoute:output_type -> common.v1.RetrieveEntityRes
 	5, // [5:10] is the sub-list for method output_type
 	0, // [0:5] is the sub-list for method input_type
 	0, // [0:0] is the sub-list for extension type_name

api/grpc/channels/v1/channels_grpc.pb.go

@@ -27,7 +27,7 @@ const (
 	ChannelsService_RemoveClientConnections_FullMethodName      = "/channels.v1.ChannelsService/RemoveClientConnections"
 	ChannelsService_UnsetParentGroupFromChannels_FullMethodName = "/channels.v1.ChannelsService/UnsetParentGroupFromChannels"
 	ChannelsService_RetrieveEntity_FullMethodName               = "/channels.v1.ChannelsService/RetrieveEntity"
-	ChannelsService_RetrieveByRoute_FullMethodName              = "/channels.v1.ChannelsService/RetrieveByRoute"
+	ChannelsService_RetrieveIDByRoute_FullMethodName            = "/channels.v1.ChannelsService/RetrieveIDByRoute"
 )
 
 // ChannelsServiceClient is the client API for ChannelsService service.
@@ -38,7 +38,7 @@ type ChannelsServiceClient interface {
 	RemoveClientConnections(ctx context.Context, in *RemoveClientConnectionsReq, opts ...grpc.CallOption) (*RemoveClientConnectionsRes, error)
 	UnsetParentGroupFromChannels(ctx context.Context, in *UnsetParentGroupFromChannelsReq, opts ...grpc.CallOption) (*UnsetParentGroupFromChannelsRes, error)
 	RetrieveEntity(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)
+	RetrieveIDByRoute(ctx context.Context, in *v1.RetrieveIDByRouteReq, opts ...grpc.CallOption) (*v1.RetrieveEntityRes, error)
 }
 
 type channelsServiceClient struct {
@@ -89,10 +89,10 @@ func (c *channelsServiceClient) RetrieveEntity(ctx context.Context, in *v1.Retri
 	return out, nil
 }
 
-func (c *channelsServiceClient) RetrieveByRoute(ctx context.Context, in *v1.RetrieveByRouteReq, opts ...grpc.CallOption) (*v1.RetrieveEntityRes, error) {
+func (c *channelsServiceClient) RetrieveIDByRoute(ctx context.Context, in *v1.RetrieveIDByRouteReq, opts ...grpc.CallOption) (*v1.RetrieveEntityRes, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(v1.RetrieveEntityRes)
-	err := c.cc.Invoke(ctx, ChannelsService_RetrieveByRoute_FullMethodName, in, out, cOpts...)
+	err := c.cc.Invoke(ctx, ChannelsService_RetrieveIDByRoute_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -107,7 +107,7 @@ type ChannelsServiceServer interface {
 	RemoveClientConnections(context.Context, *RemoveClientConnectionsReq) (*RemoveClientConnectionsRes, error)
 	UnsetParentGroupFromChannels(context.Context, *UnsetParentGroupFromChannelsReq) (*UnsetParentGroupFromChannelsRes, error)
 	RetrieveEntity(context.Context, *v1.RetrieveEntityReq) (*v1.RetrieveEntityRes, error)
-	RetrieveByRoute(context.Context, *v1.RetrieveByRouteReq) (*v1.RetrieveEntityRes, error)
+	RetrieveIDByRoute(context.Context, *v1.RetrieveIDByRouteReq) (*v1.RetrieveEntityRes, error)
 	mustEmbedUnimplementedChannelsServiceServer()
 }
 
@@ -130,8 +130,8 @@ func (UnimplementedChannelsServiceServer) UnsetParentGroupFromChannels(context.C
 func (UnimplementedChannelsServiceServer) RetrieveEntity(context.Context, *v1.RetrieveEntityReq) (*v1.RetrieveEntityRes, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method RetrieveEntity not implemented")
 }
-func (UnimplementedChannelsServiceServer) RetrieveByRoute(context.Context, *v1.RetrieveByRouteReq) (*v1.RetrieveEntityRes, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method RetrieveByRoute not implemented")
+func (UnimplementedChannelsServiceServer) RetrieveIDByRoute(context.Context, *v1.RetrieveIDByRouteReq) (*v1.RetrieveEntityRes, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method RetrieveIDByRoute not implemented")
 }
 func (UnimplementedChannelsServiceServer) mustEmbedUnimplementedChannelsServiceServer() {}
 func (UnimplementedChannelsServiceServer) testEmbeddedByValue()                         {}
@@ -226,20 +226,20 @@ func _ChannelsService_RetrieveEntity_Handler(srv interface{}, ctx context.Contex
 	return interceptor(ctx, in, info, handler)
 }
 
-func _ChannelsService_RetrieveByRoute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(v1.RetrieveByRouteReq)
+func _ChannelsService_RetrieveIDByRoute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(v1.RetrieveIDByRouteReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(ChannelsServiceServer).RetrieveByRoute(ctx, in)
+		return srv.(ChannelsServiceServer).RetrieveIDByRoute(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: ChannelsService_RetrieveByRoute_FullMethodName,
+		FullMethod: ChannelsService_RetrieveIDByRoute_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(ChannelsServiceServer).RetrieveByRoute(ctx, req.(*v1.RetrieveByRouteReq))
+		return srv.(ChannelsServiceServer).RetrieveIDByRoute(ctx, req.(*v1.RetrieveIDByRouteReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -268,8 +268,8 @@ var ChannelsService_ServiceDesc = grpc.ServiceDesc{
 			Handler:    _ChannelsService_RetrieveEntity_Handler,
 		},
 		{
-			MethodName: "RetrieveByRoute",
-			Handler:    _ChannelsService_RetrieveByRoute_Handler,
+			MethodName: "RetrieveIDByRoute",
+			Handler:    _ChannelsService_RetrieveIDByRoute_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},

api/grpc/common/v1/common.pb.go

@@ -536,7 +536,7 @@ func (x *Connection) GetType() uint32 {
 	return 0
 }
 
-type RetrieveByRouteReq struct {
+type RetrieveIDByRouteReq struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
 	Route         string                 `protobuf:"bytes,1,opt,name=route,proto3" json:"route,omitempty"`
 	DomainId      string                 `protobuf:"bytes,2,opt,name=domain_id,json=domainId,proto3" json:"domain_id,omitempty"`
@@ -544,20 +544,20 @@ type RetrieveByRouteReq struct {
 	sizeCache     protoimpl.SizeCache
 }
 
-func (x *RetrieveByRouteReq) Reset() {
-	*x = RetrieveByRouteReq{}
+func (x *RetrieveIDByRouteReq) Reset() {
+	*x = RetrieveIDByRouteReq{}
 	mi := &file_common_v1_common_proto_msgTypes[10]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *RetrieveByRouteReq) String() string {
+func (x *RetrieveIDByRouteReq) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*RetrieveByRouteReq) ProtoMessage() {}
+func (*RetrieveIDByRouteReq) ProtoMessage() {}
 
-func (x *RetrieveByRouteReq) ProtoReflect() protoreflect.Message {
+func (x *RetrieveIDByRouteReq) ProtoReflect() protoreflect.Message {
 	mi := &file_common_v1_common_proto_msgTypes[10]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -569,19 +569,19 @@ func (x *RetrieveByRouteReq) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use RetrieveByRouteReq.ProtoReflect.Descriptor instead.
-func (*RetrieveByRouteReq) Descriptor() ([]byte, []int) {
+// Deprecated: Use RetrieveIDByRouteReq.ProtoReflect.Descriptor instead.
+func (*RetrieveIDByRouteReq) Descriptor() ([]byte, []int) {
 	return file_common_v1_common_proto_rawDescGZIP(), []int{10}
 }
 
-func (x *RetrieveByRouteReq) GetRoute() string {
+func (x *RetrieveIDByRouteReq) GetRoute() string {
 	if x != nil {
 		return x.Route
 	}
 	return ""
 }
 
-func (x *RetrieveByRouteReq) GetDomainId() string {
+func (x *RetrieveIDByRouteReq) GetDomainId() string {
 	if x != nil {
 		return x.DomainId
 	}
@@ -623,8 +623,8 @@ const file_common_v1_common_proto_rawDesc = "" +
 	"\n" +
 	"channel_id\x18\x02 \x01(\tR\tchannelId\x12\x1b\n" +
 	"\tdomain_id\x18\x03 \x01(\tR\bdomainId\x12\x12\n" +
-	"\x04type\x18\x04 \x01(\rR\x04type\"G\n" +
-	"\x12RetrieveByRouteReq\x12\x14\n" +
+	"\x04type\x18\x04 \x01(\rR\x04type\"I\n" +
+	"\x14RetrieveIDByRouteReq\x12\x14\n" +
 	"\x05route\x18\x01 \x01(\tR\x05route\x12\x1b\n" +
 	"\tdomain_id\x18\x02 \x01(\tR\bdomainIdB/Z-github.com/absmach/supermq/api/grpc/common/v1b\x06proto3"
 
@@ -652,7 +652,7 @@ var file_common_v1_common_proto_goTypes = []any{
 	(*RemoveConnectionsReq)(nil), // 7: common.v1.RemoveConnectionsReq
 	(*RemoveConnectionsRes)(nil), // 8: common.v1.RemoveConnectionsRes
 	(*Connection)(nil),           // 9: common.v1.Connection
-	(*RetrieveByRouteReq)(nil),   // 10: common.v1.RetrieveByRouteReq
+	(*RetrieveIDByRouteReq)(nil), // 10: common.v1.RetrieveIDByRouteReq
 }
 var file_common_v1_common_proto_depIdxs = []int32{
 	4, // 0: common.v1.RetrieveEntitiesRes.entities:type_name -> common.v1.EntityBasic

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

@@ -122,11 +122,11 @@ const file_domains_v1_domains_proto_rawDesc = "" +
 	"\rDeleteUserRes\x12\x18\n" +
 	"\adeleted\x18\x01 \x01(\bR\adeleted\"\x1f\n" +
 	"\rDeleteUserReq\x12\x0e\n" +
-	"\x02id\x18\x01 \x01(\tR\x02id2\x83\x02\n" +
+	"\x02id\x18\x01 \x01(\tR\x02id2\x87\x02\n" +
 	"\x0eDomainsService\x12O\n" +
 	"\x15DeleteUserFromDomains\x12\x19.domains.v1.DeleteUserReq\x1a\x19.domains.v1.DeleteUserRes\"\x00\x12N\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"
+	"\x0eRetrieveStatus\x12\x1c.common.v1.RetrieveEntityReq\x1a\x1c.common.v1.RetrieveEntityRes\"\x00\x12T\n" +
+	"\x11RetrieveIDByRoute\x12\x1f.common.v1.RetrieveIDByRouteReq\x1a\x1c.common.v1.RetrieveEntityRes\"\x00B5Z3github.com/absmach/supermq/internal/grpc/domains/v1b\x06proto3"
 
 var (
 	file_domains_v1_domains_proto_rawDescOnce sync.Once
@@ -142,19 +142,19 @@ func file_domains_v1_domains_proto_rawDescGZIP() []byte {
 
 var file_domains_v1_domains_proto_msgTypes = make([]protoimpl.MessageInfo, 2)
 var file_domains_v1_domains_proto_goTypes = []any{
-	(*DeleteUserRes)(nil),         // 0: domains.v1.DeleteUserRes
-	(*DeleteUserReq)(nil),         // 1: domains.v1.DeleteUserReq
-	(*v1.RetrieveEntityReq)(nil),  // 2: common.v1.RetrieveEntityReq
-	(*v1.RetrieveByRouteReq)(nil), // 3: common.v1.RetrieveByRouteReq
-	(*v1.RetrieveEntityRes)(nil),  // 4: common.v1.RetrieveEntityRes
+	(*DeleteUserRes)(nil),           // 0: domains.v1.DeleteUserRes
+	(*DeleteUserReq)(nil),           // 1: domains.v1.DeleteUserReq
+	(*v1.RetrieveEntityReq)(nil),    // 2: common.v1.RetrieveEntityReq
+	(*v1.RetrieveIDByRouteReq)(nil), // 3: common.v1.RetrieveIDByRouteReq
+	(*v1.RetrieveEntityRes)(nil),    // 4: common.v1.RetrieveEntityRes
 }
 var file_domains_v1_domains_proto_depIdxs = []int32{
 	1, // 0: domains.v1.DomainsService.DeleteUserFromDomains:input_type -> domains.v1.DeleteUserReq
 	2, // 1: domains.v1.DomainsService.RetrieveStatus:input_type -> common.v1.RetrieveEntityReq
-	3, // 2: domains.v1.DomainsService.RetrieveByRoute:input_type -> common.v1.RetrieveByRouteReq
+	3, // 2: domains.v1.DomainsService.RetrieveIDByRoute:input_type -> common.v1.RetrieveIDByRouteReq
 	0, // 3: domains.v1.DomainsService.DeleteUserFromDomains:output_type -> domains.v1.DeleteUserRes
 	4, // 4: domains.v1.DomainsService.RetrieveStatus:output_type -> common.v1.RetrieveEntityRes
-	4, // 5: domains.v1.DomainsService.RetrieveByRoute:output_type -> common.v1.RetrieveEntityRes
+	4, // 5: domains.v1.DomainsService.RetrieveIDByRoute: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
 	0, // [0:0] is the sub-list for extension type_name

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

@@ -25,7 +25,7 @@ const _ = grpc.SupportPackageIsVersion9
 const (
 	DomainsService_DeleteUserFromDomains_FullMethodName = "/domains.v1.DomainsService/DeleteUserFromDomains"
 	DomainsService_RetrieveStatus_FullMethodName        = "/domains.v1.DomainsService/RetrieveStatus"
-	DomainsService_RetrieveByRoute_FullMethodName       = "/domains.v1.DomainsService/RetrieveByRoute"
+	DomainsService_RetrieveIDByRoute_FullMethodName     = "/domains.v1.DomainsService/RetrieveIDByRoute"
 )
 
 // DomainsServiceClient is the client API for DomainsService service.
@@ -37,7 +37,7 @@ const (
 type DomainsServiceClient interface {
 	DeleteUserFromDomains(ctx context.Context, in *DeleteUserReq, opts ...grpc.CallOption) (*DeleteUserRes, 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)
+	RetrieveIDByRoute(ctx context.Context, in *v1.RetrieveIDByRouteReq, opts ...grpc.CallOption) (*v1.RetrieveEntityRes, error)
 }
 
 type domainsServiceClient struct {
@@ -68,10 +68,10 @@ func (c *domainsServiceClient) RetrieveStatus(ctx context.Context, in *v1.Retrie
 	return out, nil
 }
 
-func (c *domainsServiceClient) RetrieveByRoute(ctx context.Context, in *v1.RetrieveByRouteReq, opts ...grpc.CallOption) (*v1.RetrieveEntityRes, error) {
+func (c *domainsServiceClient) RetrieveIDByRoute(ctx context.Context, in *v1.RetrieveIDByRouteReq, opts ...grpc.CallOption) (*v1.RetrieveEntityRes, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
 	out := new(v1.RetrieveEntityRes)
-	err := c.cc.Invoke(ctx, DomainsService_RetrieveByRoute_FullMethodName, in, out, cOpts...)
+	err := c.cc.Invoke(ctx, DomainsService_RetrieveIDByRoute_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -87,7 +87,7 @@ func (c *domainsServiceClient) RetrieveByRoute(ctx context.Context, in *v1.Retri
 type DomainsServiceServer interface {
 	DeleteUserFromDomains(context.Context, *DeleteUserReq) (*DeleteUserRes, error)
 	RetrieveStatus(context.Context, *v1.RetrieveEntityReq) (*v1.RetrieveEntityRes, error)
-	RetrieveByRoute(context.Context, *v1.RetrieveByRouteReq) (*v1.RetrieveEntityRes, error)
+	RetrieveIDByRoute(context.Context, *v1.RetrieveIDByRouteReq) (*v1.RetrieveEntityRes, error)
 	mustEmbedUnimplementedDomainsServiceServer()
 }
 
@@ -104,8 +104,8 @@ func (UnimplementedDomainsServiceServer) DeleteUserFromDomains(context.Context,
 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")
+func (UnimplementedDomainsServiceServer) RetrieveIDByRoute(context.Context, *v1.RetrieveIDByRouteReq) (*v1.RetrieveEntityRes, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method RetrieveIDByRoute not implemented")
 }
 func (UnimplementedDomainsServiceServer) mustEmbedUnimplementedDomainsServiceServer() {}
 func (UnimplementedDomainsServiceServer) testEmbeddedByValue()                        {}
@@ -164,20 +164,20 @@ func _DomainsService_RetrieveStatus_Handler(srv interface{}, ctx context.Context
 	return interceptor(ctx, in, info, handler)
 }
 
-func _DomainsService_RetrieveByRoute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(v1.RetrieveByRouteReq)
+func _DomainsService_RetrieveIDByRoute_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(v1.RetrieveIDByRouteReq)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(DomainsServiceServer).RetrieveByRoute(ctx, in)
+		return srv.(DomainsServiceServer).RetrieveIDByRoute(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: DomainsService_RetrieveByRoute_FullMethodName,
+		FullMethod: DomainsService_RetrieveIDByRoute_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(DomainsServiceServer).RetrieveByRoute(ctx, req.(*v1.RetrieveByRouteReq))
+		return srv.(DomainsServiceServer).RetrieveIDByRoute(ctx, req.(*v1.RetrieveIDByRouteReq))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -198,8 +198,8 @@ var DomainsService_ServiceDesc = grpc.ServiceDesc{
 			Handler:    _DomainsService_RetrieveStatus_Handler,
 		},
 		{
-			MethodName: "RetrieveByRoute",
-			Handler:    _DomainsService_RetrieveByRoute_Handler,
+			MethodName: "RetrieveIDByRoute",
+			Handler:    _DomainsService_RetrieveIDByRoute_Handler,
 		},
 	},
 	Streams:  []grpc.StreamDesc{},

channels/api/grpc/client.go

@@ -30,7 +30,7 @@ type grpcClient struct {
 	removeClientConnections      endpoint.Endpoint
 	unsetParentGroupFromChannels endpoint.Endpoint
 	retrieveEntity               endpoint.Endpoint
-	retrieveByRoute              endpoint.Endpoint
+	retrieveIDByRoute            endpoint.Endpoint
 }
 
 // NewClient returns new gRPC client instance.
@@ -68,12 +68,12 @@ func NewClient(conn *grpc.ClientConn, timeout time.Duration) grpcChannelsV1.Chan
 			decodeRetrieveEntityResponse,
 			grpcCommonV1.RetrieveEntityRes{},
 		).Endpoint(),
-		retrieveByRoute: kitgrpc.NewClient(
+		retrieveIDByRoute: kitgrpc.NewClient(
 			conn,
 			svcName,
-			"RetrieveByRoute",
-			encodeRetrieveByRouteRequest,
-			decodeRetrieveByRouteResponse,
+			"RetrieveIDByRoute",
+			encodeRetrieveIDByRouteRequest,
+			decodeRetrieveIDByRouteResponse,
 			grpcCommonV1.RetrieveEntityRes{},
 		).Endpoint(),
 		timeout: timeout,
@@ -176,11 +176,11 @@ func decodeRetrieveEntityResponse(_ context.Context, grpcRes interface{}) (inter
 	return grpcRes.(*grpcCommonV1.RetrieveEntityRes), nil
 }
 
-func (client grpcClient) RetrieveByRoute(ctx context.Context, req *grpcCommonV1.RetrieveByRouteReq, _ ...grpc.CallOption) (r *grpcCommonV1.RetrieveEntityRes, err error) {
+func (client grpcClient) RetrieveIDByRoute(ctx context.Context, req *grpcCommonV1.RetrieveIDByRouteReq, _ ...grpc.CallOption) (r *grpcCommonV1.RetrieveEntityRes, err error) {
 	ctx, cancel := context.WithTimeout(ctx, client.timeout)
 	defer cancel()
 
-	res, err := client.retrieveByRoute(ctx, req)
+	res, err := client.retrieveIDByRoute(ctx, req)
 	if err != nil {
 		return &grpcCommonV1.RetrieveEntityRes{}, decodeError(err)
 	}
@@ -188,11 +188,11 @@ func (client grpcClient) RetrieveByRoute(ctx context.Context, req *grpcCommonV1.
 	return res.(*grpcCommonV1.RetrieveEntityRes), nil
 }
 
-func encodeRetrieveByRouteRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
-	return grpcReq.(*grpcCommonV1.RetrieveByRouteReq), nil
+func encodeRetrieveIDByRouteRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
+	return grpcReq.(*grpcCommonV1.RetrieveIDByRouteReq), nil
 }
 
-func decodeRetrieveByRouteResponse(_ context.Context, grpcRes interface{}) (interface{}, error) {
+func decodeRetrieveIDByRouteResponse(_ context.Context, grpcRes interface{}) (interface{}, error) {
 	return grpcRes.(*grpcCommonV1.RetrieveEntityRes), nil
 }
 

channels/api/grpc/endpoint.go

@@ -68,18 +68,18 @@ func retrieveEntityEndpoint(svc channels.Service) endpoint.Endpoint {
 	}
 }
 
-func retrieveByRouteEndpoint(svc channels.Service) endpoint.Endpoint {
+func retrieveIDByRouteEndpoint(svc channels.Service) endpoint.Endpoint {
 	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(retrieveByRouteReq)
+		req := request.(retrieveIDByRouteReq)
 		if err := req.validate(); err != nil {
-			return retrieveEntityRes{}, err
+			return retrieveIDByRouteRes{}, err
 		}
 
-		channel, err := svc.RetrieveByRoute(ctx, req.route, req.domainID)
+		id, err := svc.RetrieveIDByRoute(ctx, req.route, req.domainID)
 		if err != nil {
-			return retrieveEntityRes{}, err
+			return retrieveIDByRouteRes{}, err
 		}
 
-		return retrieveEntityRes{id: channel.ID, status: uint8(channel.Status)}, nil
+		return retrieveIDByRouteRes{id: id}, nil
 	}
 }

channels/api/grpc/endpoint_test.go

@@ -267,7 +267,7 @@ func TestRetrieveEntity(t *testing.T) {
 	}
 }
 
-func TestRetrieveByRoute(t *testing.T) {
+func TestRetrieveIDByRoute(t *testing.T) {
 	svc := new(mocks.Service)
 	server := startGRPCServer(svc, port)
 	defer server.GracefulStop()
@@ -278,62 +278,55 @@ func TestRetrieveByRoute(t *testing.T) {
 	validRoute := "validRoute"
 	domainID := testsutil.GenerateUUID(t)
 
-	channel := ch.Channel{
-		ID:     validID,
-		Route:  validRoute,
-		Status: channels.EnabledStatus,
-	}
-
 	cases := []struct {
 		desc        string
-		retrieveReq *grpcCommonV1.RetrieveByRouteReq
-		svcRes      ch.Channel
+		retrieveReq *grpcCommonV1.RetrieveIDByRouteReq
+		svcRes      string
 		svcErr      error
 		retrieveRes *grpcCommonV1.RetrieveEntityRes
 		err         error
 	}{
 		{
 			desc: "retrieve entity by route successfully",
-			retrieveReq: &grpcCommonV1.RetrieveByRouteReq{
+			retrieveReq: &grpcCommonV1.RetrieveIDByRouteReq{
 				Route:    validRoute,
 				DomainId: domainID,
 			},
-			svcRes: channel,
+			svcRes: validID,
 			retrieveRes: &grpcCommonV1.RetrieveEntityRes{
 				Entity: &grpcCommonV1.EntityBasic{
-					Id:     channel.ID,
-					Status: uint32(ch.EnabledStatus),
+					Id: validID,
 				},
 			},
 			err: nil,
 		},
 		{
 			desc: "retrieve entity by route with empty route",
-			retrieveReq: &grpcCommonV1.RetrieveByRouteReq{
+			retrieveReq: &grpcCommonV1.RetrieveIDByRouteReq{
 				Route:    "",
 				DomainId: domainID,
 			},
-			svcRes:      ch.Channel{},
+			svcRes:      "",
 			retrieveRes: &grpcCommonV1.RetrieveEntityRes{},
 			err:         apiutil.ErrMissingRoute,
 		},
 		{
 			desc: "retrieve entity by route with empty domain ID",
-			retrieveReq: &grpcCommonV1.RetrieveByRouteReq{
+			retrieveReq: &grpcCommonV1.RetrieveIDByRouteReq{
 				Route:    validRoute,
 				DomainId: "",
 			},
-			svcRes:      ch.Channel{},
+			svcRes:      "",
 			retrieveRes: &grpcCommonV1.RetrieveEntityRes{},
 			err:         apiutil.ErrMissingDomainID,
 		},
 		{
 			desc: "retrieve entity by route with invalid route",
-			retrieveReq: &grpcCommonV1.RetrieveByRouteReq{
+			retrieveReq: &grpcCommonV1.RetrieveIDByRouteReq{
 				Route:    "invalidRoute",
 				DomainId: domainID,
 			},
-			svcRes:      ch.Channel{},
+			svcRes:      "",
 			svcErr:      svcerr.ErrNotFound,
 			retrieveRes: &grpcCommonV1.RetrieveEntityRes{},
 			err:         svcerr.ErrNotFound,
@@ -342,8 +335,8 @@ func TestRetrieveByRoute(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			svcCall := svc.On("RetrieveByRoute", mock.Anything, tc.retrieveReq.Route, tc.retrieveReq.DomainId).Return(tc.svcRes, tc.svcErr)
-			res, err := client.RetrieveByRoute(context.Background(), tc.retrieveReq)
+			svcCall := svc.On("RetrieveIDByRoute", mock.Anything, tc.retrieveReq.Route, tc.retrieveReq.DomainId).Return(tc.svcRes, tc.svcErr)
+			res, err := client.RetrieveIDByRoute(context.Background(), tc.retrieveReq)
 			assert.True(t, errors.Contains(err, tc.err), fmt.Sprintf("%s: expected %s got %s", tc.desc, tc.err, err))
 			assert.Equal(t, tc.retrieveRes.Entity, res.Entity)
 			svcCall.Unset()

channels/api/grpc/request.go

@@ -39,12 +39,12 @@ type retrieveEntityReq struct {
 	Id string
 }
 
-type retrieveByRouteReq struct {
+type retrieveIDByRouteReq struct {
 	route    string
 	domainID string
 }
 
-func (req retrieveByRouteReq) validate() error {
+func (req retrieveIDByRouteReq) validate() error {
 	if req.route == "" {
 		return apiutil.ErrMissingRoute
 	}

channels/api/grpc/responses.go

@@ -19,3 +19,7 @@ type channelBasic struct {
 }
 
 type retrieveEntityRes channelBasic
+
+type retrieveIDByRouteRes struct {
+	id string
+}

channels/api/grpc/server.go

@@ -27,7 +27,7 @@ type grpcServer struct {
 	removeClientConnections      kitgrpc.Handler
 	unsetParentGroupFromChannels kitgrpc.Handler
 	retrieveEntity               kitgrpc.Handler
-	retrieveByRoute              kitgrpc.Handler
+	retrieveIDByRoute            kitgrpc.Handler
 }
 
 // NewServer returns new AuthServiceServer instance.
@@ -53,10 +53,10 @@ func NewServer(svc channels.Service) grpcChannelsV1.ChannelsServiceServer {
 			decodeRetrieveEntityRequest,
 			encodeRetrieveEntityResponse,
 		),
-		retrieveByRoute: kitgrpc.NewServer(
-			retrieveByRouteEndpoint(svc),
-			decodeRetrieveByRouteRequest,
-			encodeRetrieveByRouteResponse,
+		retrieveIDByRoute: kitgrpc.NewServer(
+			retrieveIDByRouteEndpoint(svc),
+			decodeRetrieveIDByRouteRequest,
+			encodeRetrieveIDByRouteResponse,
 		),
 	}
 }
@@ -160,27 +160,26 @@ func encodeRetrieveEntityResponse(_ context.Context, grpcRes interface{}) (inter
 	}, nil
 }
 
-func decodeRetrieveByRouteRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
-	req := grpcReq.(*grpcCommonV1.RetrieveByRouteReq)
-	return retrieveByRouteReq{
+func decodeRetrieveIDByRouteRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
+	req := grpcReq.(*grpcCommonV1.RetrieveIDByRouteReq)
+	return retrieveIDByRouteReq{
 		route:    req.GetRoute(),
 		domainID: req.GetDomainId(),
 	}, nil
 }
 
-func encodeRetrieveByRouteResponse(_ context.Context, grpcRes interface{}) (interface{}, error) {
-	res := grpcRes.(retrieveEntityRes)
+func encodeRetrieveIDByRouteResponse(_ context.Context, grpcRes interface{}) (interface{}, error) {
+	res := grpcRes.(retrieveIDByRouteRes)
 
 	return &grpcCommonV1.RetrieveEntityRes{
 		Entity: &grpcCommonV1.EntityBasic{
-			Id:     res.id,
-			Status: uint32(res.status),
+			Id: res.id,
 		},
 	}, nil
 }
 
-func (s *grpcServer) RetrieveByRoute(ctx context.Context, req *grpcCommonV1.RetrieveByRouteReq) (*grpcCommonV1.RetrieveEntityRes, error) {
-	_, res, err := s.retrieveByRoute.ServeGRPC(ctx, req)
+func (s *grpcServer) RetrieveIDByRoute(ctx context.Context, req *grpcCommonV1.RetrieveIDByRouteReq) (*grpcCommonV1.RetrieveEntityRes, error) {
+	_, res, err := s.retrieveIDByRoute.ServeGRPC(ctx, req)
 	if err != nil {
 		return nil, encodeError(err)
 	}

channels/mocks/channels_client.go

@@ -209,89 +209,6 @@ func (_c *ChannelsServiceClient_RemoveClientConnections_Call) RunAndReturn(run f
 	return _c
 }
 
-// RetrieveByRoute provides a mock function for the type ChannelsServiceClient
-func (_mock *ChannelsServiceClient) RetrieveByRoute(ctx context.Context, in *v10.RetrieveByRouteReq, opts ...grpc.CallOption) (*v10.RetrieveEntityRes, error) {
-	var tmpRet mock.Arguments
-	if len(opts) > 0 {
-		tmpRet = _mock.Called(ctx, in, opts)
-	} else {
-		tmpRet = _mock.Called(ctx, in)
-	}
-	ret := tmpRet
-
-	if len(ret) == 0 {
-		panic("no return value specified for RetrieveByRoute")
-	}
-
-	var r0 *v10.RetrieveEntityRes
-	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, *v10.RetrieveByRouteReq, ...grpc.CallOption) (*v10.RetrieveEntityRes, error)); ok {
-		return returnFunc(ctx, in, opts...)
-	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, *v10.RetrieveByRouteReq, ...grpc.CallOption) *v10.RetrieveEntityRes); ok {
-		r0 = returnFunc(ctx, in, opts...)
-	} else {
-		if ret.Get(0) != nil {
-			r0 = ret.Get(0).(*v10.RetrieveEntityRes)
-		}
-	}
-	if returnFunc, ok := ret.Get(1).(func(context.Context, *v10.RetrieveByRouteReq, ...grpc.CallOption) error); ok {
-		r1 = returnFunc(ctx, in, opts...)
-	} else {
-		r1 = ret.Error(1)
-	}
-	return r0, r1
-}
-
-// ChannelsServiceClient_RetrieveByRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveByRoute'
-type ChannelsServiceClient_RetrieveByRoute_Call struct {
-	*mock.Call
-}
-
-// RetrieveByRoute is a helper method to define mock.On call
-//   - ctx context.Context
-//   - in *v10.RetrieveByRouteReq
-//   - opts ...grpc.CallOption
-func (_e *ChannelsServiceClient_Expecter) RetrieveByRoute(ctx interface{}, in interface{}, opts ...interface{}) *ChannelsServiceClient_RetrieveByRoute_Call {
-	return &ChannelsServiceClient_RetrieveByRoute_Call{Call: _e.mock.On("RetrieveByRoute",
-		append([]interface{}{ctx, in}, opts...)...)}
-}
-
-func (_c *ChannelsServiceClient_RetrieveByRoute_Call) Run(run func(ctx context.Context, in *v10.RetrieveByRouteReq, opts ...grpc.CallOption)) *ChannelsServiceClient_RetrieveByRoute_Call {
-	_c.Call.Run(func(args mock.Arguments) {
-		var arg0 context.Context
-		if args[0] != nil {
-			arg0 = args[0].(context.Context)
-		}
-		var arg1 *v10.RetrieveByRouteReq
-		if args[1] != nil {
-			arg1 = args[1].(*v10.RetrieveByRouteReq)
-		}
-		var arg2 []grpc.CallOption
-		var variadicArgs []grpc.CallOption
-		if len(args) > 2 {
-			variadicArgs = args[2].([]grpc.CallOption)
-		}
-		arg2 = variadicArgs
-		run(
-			arg0,
-			arg1,
-			arg2...,
-		)
-	})
-	return _c
-}
-
-func (_c *ChannelsServiceClient_RetrieveByRoute_Call) Return(retrieveEntityRes *v10.RetrieveEntityRes, err error) *ChannelsServiceClient_RetrieveByRoute_Call {
-	_c.Call.Return(retrieveEntityRes, err)
-	return _c
-}
-
-func (_c *ChannelsServiceClient_RetrieveByRoute_Call) RunAndReturn(run func(ctx context.Context, in *v10.RetrieveByRouteReq, opts ...grpc.CallOption) (*v10.RetrieveEntityRes, error)) *ChannelsServiceClient_RetrieveByRoute_Call {
-	_c.Call.Return(run)
-	return _c
-}
-
 // RetrieveEntity provides a mock function for the type ChannelsServiceClient
 func (_mock *ChannelsServiceClient) RetrieveEntity(ctx context.Context, in *v10.RetrieveEntityReq, opts ...grpc.CallOption) (*v10.RetrieveEntityRes, error) {
 	var tmpRet mock.Arguments
@@ -375,6 +292,89 @@ func (_c *ChannelsServiceClient_RetrieveEntity_Call) RunAndReturn(run func(ctx c
 	return _c
 }
 
+// RetrieveIDByRoute provides a mock function for the type ChannelsServiceClient
+func (_mock *ChannelsServiceClient) RetrieveIDByRoute(ctx context.Context, in *v10.RetrieveIDByRouteReq, opts ...grpc.CallOption) (*v10.RetrieveEntityRes, error) {
+	var tmpRet mock.Arguments
+	if len(opts) > 0 {
+		tmpRet = _mock.Called(ctx, in, opts)
+	} else {
+		tmpRet = _mock.Called(ctx, in)
+	}
+	ret := tmpRet
+
+	if len(ret) == 0 {
+		panic("no return value specified for RetrieveIDByRoute")
+	}
+
+	var r0 *v10.RetrieveEntityRes
+	var r1 error
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *v10.RetrieveIDByRouteReq, ...grpc.CallOption) (*v10.RetrieveEntityRes, error)); ok {
+		return returnFunc(ctx, in, opts...)
+	}
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *v10.RetrieveIDByRouteReq, ...grpc.CallOption) *v10.RetrieveEntityRes); ok {
+		r0 = returnFunc(ctx, in, opts...)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(*v10.RetrieveEntityRes)
+		}
+	}
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *v10.RetrieveIDByRouteReq, ...grpc.CallOption) error); ok {
+		r1 = returnFunc(ctx, in, opts...)
+	} else {
+		r1 = ret.Error(1)
+	}
+	return r0, r1
+}
+
+// ChannelsServiceClient_RetrieveIDByRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveIDByRoute'
+type ChannelsServiceClient_RetrieveIDByRoute_Call struct {
+	*mock.Call
+}
+
+// RetrieveIDByRoute is a helper method to define mock.On call
+//   - ctx context.Context
+//   - in *v10.RetrieveIDByRouteReq
+//   - opts ...grpc.CallOption
+func (_e *ChannelsServiceClient_Expecter) RetrieveIDByRoute(ctx interface{}, in interface{}, opts ...interface{}) *ChannelsServiceClient_RetrieveIDByRoute_Call {
+	return &ChannelsServiceClient_RetrieveIDByRoute_Call{Call: _e.mock.On("RetrieveIDByRoute",
+		append([]interface{}{ctx, in}, opts...)...)}
+}
+
+func (_c *ChannelsServiceClient_RetrieveIDByRoute_Call) Run(run func(ctx context.Context, in *v10.RetrieveIDByRouteReq, opts ...grpc.CallOption)) *ChannelsServiceClient_RetrieveIDByRoute_Call {
+	_c.Call.Run(func(args mock.Arguments) {
+		var arg0 context.Context
+		if args[0] != nil {
+			arg0 = args[0].(context.Context)
+		}
+		var arg1 *v10.RetrieveIDByRouteReq
+		if args[1] != nil {
+			arg1 = args[1].(*v10.RetrieveIDByRouteReq)
+		}
+		var arg2 []grpc.CallOption
+		var variadicArgs []grpc.CallOption
+		if len(args) > 2 {
+			variadicArgs = args[2].([]grpc.CallOption)
+		}
+		arg2 = variadicArgs
+		run(
+			arg0,
+			arg1,
+			arg2...,
+		)
+	})
+	return _c
+}
+
+func (_c *ChannelsServiceClient_RetrieveIDByRoute_Call) Return(retrieveEntityRes *v10.RetrieveEntityRes, err error) *ChannelsServiceClient_RetrieveIDByRoute_Call {
+	_c.Call.Return(retrieveEntityRes, err)
+	return _c
+}
+
+func (_c *ChannelsServiceClient_RetrieveIDByRoute_Call) RunAndReturn(run func(ctx context.Context, in *v10.RetrieveIDByRouteReq, opts ...grpc.CallOption) (*v10.RetrieveEntityRes, error)) *ChannelsServiceClient_RetrieveIDByRoute_Call {
+	_c.Call.Return(run)
+	return _c
+}
+
 // UnsetParentGroupFromChannels provides a mock function for the type ChannelsServiceClient
 func (_mock *ChannelsServiceClient) UnsetParentGroupFromChannels(ctx context.Context, in *v1.UnsetParentGroupFromChannelsReq, opts ...grpc.CallOption) (*v1.UnsetParentGroupFromChannelsRes, error) {
 	var tmpRet mock.Arguments

channels/private/mocks/service.go

@@ -221,23 +221,23 @@ func (_c *Service_RetrieveByID_Call) RunAndReturn(run func(ctx context.Context,
 	return _c
 }
 
-// RetrieveByRoute provides a mock function for the type Service
-func (_mock *Service) RetrieveByRoute(ctx context.Context, route string, domainID string) (channels.Channel, error) {
+// RetrieveIDByRoute provides a mock function for the type Service
+func (_mock *Service) RetrieveIDByRoute(ctx context.Context, route string, domainID string) (string, error) {
 	ret := _mock.Called(ctx, route, domainID)
 
 	if len(ret) == 0 {
-		panic("no return value specified for RetrieveByRoute")
+		panic("no return value specified for RetrieveIDByRoute")
 	}
 
-	var r0 channels.Channel
+	var r0 string
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (channels.Channel, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (string, error)); ok {
 		return returnFunc(ctx, route, domainID)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) channels.Channel); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) string); ok {
 		r0 = returnFunc(ctx, route, domainID)
 	} else {
-		r0 = ret.Get(0).(channels.Channel)
+		r0 = ret.Get(0).(string)
 	}
 	if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok {
 		r1 = returnFunc(ctx, route, domainID)
@@ -247,20 +247,20 @@ func (_mock *Service) RetrieveByRoute(ctx context.Context, route string, domainI
 	return r0, r1
 }
 
-// Service_RetrieveByRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveByRoute'
-type Service_RetrieveByRoute_Call struct {
+// Service_RetrieveIDByRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveIDByRoute'
+type Service_RetrieveIDByRoute_Call struct {
 	*mock.Call
 }
 
-// RetrieveByRoute is a helper method to define mock.On call
+// RetrieveIDByRoute is a helper method to define mock.On call
 //   - ctx context.Context
 //   - route string
 //   - domainID string
-func (_e *Service_Expecter) RetrieveByRoute(ctx interface{}, route interface{}, domainID interface{}) *Service_RetrieveByRoute_Call {
-	return &Service_RetrieveByRoute_Call{Call: _e.mock.On("RetrieveByRoute", ctx, route, domainID)}
+func (_e *Service_Expecter) RetrieveIDByRoute(ctx interface{}, route interface{}, domainID interface{}) *Service_RetrieveIDByRoute_Call {
+	return &Service_RetrieveIDByRoute_Call{Call: _e.mock.On("RetrieveIDByRoute", ctx, route, domainID)}
 }
 
-func (_c *Service_RetrieveByRoute_Call) Run(run func(ctx context.Context, route string, domainID string)) *Service_RetrieveByRoute_Call {
+func (_c *Service_RetrieveIDByRoute_Call) Run(run func(ctx context.Context, route string, domainID string)) *Service_RetrieveIDByRoute_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
@@ -283,12 +283,12 @@ func (_c *Service_RetrieveByRoute_Call) Run(run func(ctx context.Context, route
 	return _c
 }
 
-func (_c *Service_RetrieveByRoute_Call) Return(channel channels.Channel, err error) *Service_RetrieveByRoute_Call {
-	_c.Call.Return(channel, err)
+func (_c *Service_RetrieveIDByRoute_Call) Return(s string, err error) *Service_RetrieveIDByRoute_Call {
+	_c.Call.Return(s, err)
 	return _c
 }
 
-func (_c *Service_RetrieveByRoute_Call) RunAndReturn(run func(ctx context.Context, route string, domainID string) (channels.Channel, error)) *Service_RetrieveByRoute_Call {
+func (_c *Service_RetrieveIDByRoute_Call) RunAndReturn(run func(ctx context.Context, route string, domainID string) (string, error)) *Service_RetrieveIDByRoute_Call {
 	_c.Call.Return(run)
 	return _c
 }

channels/private/service.go

@@ -22,7 +22,7 @@ type Service interface {
 	UnsetParentGroupFromChannels(ctx context.Context, parentGroupID string) error
 	RemoveClientConnections(ctx context.Context, clientID string) error
 	RetrieveByID(ctx context.Context, id string) (channels.Channel, error)
-	RetrieveByRoute(ctx context.Context, route, domainID string) (channels.Channel, error)
+	RetrieveIDByRoute(ctx context.Context, route, domainID string) (string, error)
 }
 
 type service struct {
@@ -123,18 +123,18 @@ func (svc service) RetrieveByID(ctx context.Context, id string) (channels.Channe
 	return svc.repo.RetrieveByID(ctx, id)
 }
 
-func (svc service) RetrieveByRoute(ctx context.Context, route, domainID string) (channels.Channel, error) {
+func (svc service) RetrieveIDByRoute(ctx context.Context, route, domainID string) (string, error) {
 	id, err := svc.cache.ID(ctx, route, domainID)
 	if err == nil {
-		return channels.Channel{ID: id}, nil
+		return id, nil
 	}
 	chn, err := svc.repo.RetrieveByRoute(ctx, route, domainID)
 	if err != nil {
-		return channels.Channel{}, errors.Wrap(svcerr.ErrViewEntity, err)
+		return "", errors.Wrap(svcerr.ErrViewEntity, err)
 	}
 	if err := svc.cache.Save(ctx, route, domainID, chn.ID); err != nil {
-		return channels.Channel{}, errors.Wrap(svcerr.ErrUpdateEntity, err)
+		return "", errors.Wrap(svcerr.ErrUpdateEntity, err)
 	}
 
-	return channels.Channel{ID: chn.ID}, nil
+	return chn.ID, nil
 }

domains/api/grpc/client.go

@@ -22,7 +22,7 @@ var _ grpcDomainsV1.DomainsServiceClient = (*domainsGrpcClient)(nil)
 type domainsGrpcClient struct {
 	deleteUserFromDomains endpoint.Endpoint
 	retrieveStatus        endpoint.Endpoint
-	retrieveByRoute       endpoint.Endpoint
+	retrieveIDByRoute     endpoint.Endpoint
 	timeout               time.Duration
 }
 
@@ -45,12 +45,12 @@ func NewDomainsClient(conn *grpc.ClientConn, timeout time.Duration) grpcDomainsV
 			decodeRetrieveStatusResponse,
 			grpcCommonV1.RetrieveEntityRes{},
 		).Endpoint(),
-		retrieveByRoute: kitgrpc.NewClient(
+		retrieveIDByRoute: kitgrpc.NewClient(
 			conn,
 			domainsSvcName,
-			"RetrieveByRoute",
-			encodeRetrieveByRouteRequest,
-			decodeRetrieveByRouteResponse,
+			"RetrieveIDByRoute",
+			encodeRetrieveIDByRouteRequest,
+			decodeRetrieveIDByRouteResponse,
 			grpcCommonV1.RetrieveEntityRes{},
 		).Endpoint(),
 		timeout: timeout,
@@ -115,34 +115,33 @@ func encodeRetrieveStatusRequest(_ context.Context, grpcReq interface{}) (interf
 	}, nil
 }
 
-func (client domainsGrpcClient) RetrieveByRoute(ctx context.Context, in *grpcCommonV1.RetrieveByRouteReq, opts ...grpc.CallOption) (*grpcCommonV1.RetrieveEntityRes, error) {
+func (client domainsGrpcClient) RetrieveIDByRoute(ctx context.Context, in *grpcCommonV1.RetrieveIDByRouteReq, opts ...grpc.CallOption) (*grpcCommonV1.RetrieveEntityRes, error) {
 	ctx, cancel := context.WithTimeout(ctx, client.timeout)
 	defer cancel()
 
-	res, err := client.retrieveByRoute(ctx, retrieveByRouteReq{
+	res, err := client.retrieveIDByRoute(ctx, retrieveIDByRouteReq{
 		Route: in.GetRoute(),
 	})
 	if err != nil {
 		return &grpcCommonV1.RetrieveEntityRes{}, grpcapi.DecodeError(err)
 	}
 
-	rbr := res.(retrieveEntityRes)
+	rbr := res.(retrieveIDByRouteRes)
 	return &grpcCommonV1.RetrieveEntityRes{
 		Entity: &grpcCommonV1.EntityBasic{
-			Id:     rbr.id,
-			Status: uint32(rbr.status),
+			Id: rbr.id,
 		},
 	}, nil
 }
 
-func decodeRetrieveByRouteResponse(_ context.Context, grpcRes interface{}) (interface{}, error) {
+func decodeRetrieveIDByRouteResponse(_ context.Context, grpcRes interface{}) (interface{}, error) {
 	res := grpcRes.(*grpcCommonV1.RetrieveEntityRes)
-	return retrieveEntityRes{id: res.Entity.GetId(), status: uint8(res.Entity.GetStatus())}, nil
+	return retrieveIDByRouteRes{id: res.Entity.GetId()}, nil
 }
 
-func encodeRetrieveByRouteRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
-	req := grpcReq.(retrieveByRouteReq)
-	return &grpcCommonV1.RetrieveByRouteReq{
+func encodeRetrieveIDByRouteRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
+	req := grpcReq.(retrieveIDByRouteReq)
+	return &grpcCommonV1.RetrieveIDByRouteReq{
 		Route: req.Route,
 	}, nil
 }

domains/api/grpc/endpoint.go

@@ -43,21 +43,20 @@ func retrieveStatusEndpoint(svc domains.Service) endpoint.Endpoint {
 	}
 }
 
-func retrieveByRouteEndpoint(svc domains.Service) endpoint.Endpoint {
+func retrieveIDByRouteEndpoint(svc domains.Service) endpoint.Endpoint {
 	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(retrieveByRouteReq)
+		req := request.(retrieveIDByRouteReq)
 		if err := req.validate(); err != nil {
-			return retrieveEntityRes{}, err
+			return retrieveIDByRouteRes{}, err
 		}
 
-		dom, err := svc.RetrieveByRoute(ctx, req.Route)
+		id, err := svc.RetrieveIDByRoute(ctx, req.Route)
 		if err != nil {
-			return retrieveEntityRes{}, err
+			return retrieveIDByRouteRes{}, err
 		}
 
-		return retrieveEntityRes{
-			id:     dom.ID,
-			status: uint8(dom.Status),
+		return retrieveIDByRouteRes{
+			id: id,
 		}, nil
 	}
 }

domains/api/grpc/endpoint_test.go

@@ -162,63 +162,57 @@ func TestRetrieveStatus(t *testing.T) {
 	}
 }
 
-func TestRetrieveByRoute(t *testing.T) {
+func TestRetrieveIDByRoute(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)
 
 	validRoute := "validRoute"
-	dom := domains.Domain{
-		ID:     id,
-		Route:  validRoute,
-		Status: domains.EnabledStatus,
-	}
 
 	cases := []struct {
 		desc        string
-		retrieveReq *grpcCommonV1.RetrieveByRouteReq
-		svcRes      domains.Domain
+		retrieveReq *grpcCommonV1.RetrieveIDByRouteReq
+		svcRes      string
 		svcErr      error
 		retrieveRes *grpcCommonV1.RetrieveEntityRes
 		err         error
 	}{
 		{
-			desc: "retrieve entity with valid req",
-			retrieveReq: &grpcCommonV1.RetrieveByRouteReq{
+			desc: "retrieve id with valid route",
+			retrieveReq: &grpcCommonV1.RetrieveIDByRouteReq{
 				Route: validRoute,
 			},
-			svcRes: dom,
+			svcRes: id,
 			retrieveRes: &grpcCommonV1.RetrieveEntityRes{
 				Entity: &grpcCommonV1.EntityBasic{
-					Id:     id,
-					Status: uint32(domains.EnabledStatus),
+					Id: id,
 				},
 			},
 			err: nil,
 		},
 		{
-			desc: "retrieve entity with empty route",
-			retrieveReq: &grpcCommonV1.RetrieveByRouteReq{
+			desc: "retrieve id with empty route",
+			retrieveReq: &grpcCommonV1.RetrieveIDByRouteReq{
 				Route: "",
 			},
-			svcRes:      domains.Domain{},
+			svcRes:      "",
 			retrieveRes: &grpcCommonV1.RetrieveEntityRes{},
 			err:         apiutil.ErrMissingRoute,
 		},
 		{
-			desc: "retrieve entity with invalid route",
-			retrieveReq: &grpcCommonV1.RetrieveByRouteReq{
+			desc: "retrieve id with invalid route",
+			retrieveReq: &grpcCommonV1.RetrieveIDByRouteReq{
 				Route: "invalid",
 			},
-			svcRes:      domains.Domain{},
+			svcRes:      "",
 			svcErr:      svcerr.ErrNotFound,
 			retrieveRes: &grpcCommonV1.RetrieveEntityRes{},
 			err:         svcerr.ErrNotFound,
 		},
 	}
 	for _, tc := range cases {
-		svcCall := svc.On("RetrieveByRoute", mock.Anything, tc.retrieveReq.Route).Return(tc.svcRes, tc.svcErr)
-		dpr, err := grpcClient.RetrieveByRoute(context.Background(), tc.retrieveReq)
+		svcCall := svc.On("RetrieveIDByRoute", mock.Anything, tc.retrieveReq.Route).Return(tc.svcRes, tc.svcErr)
+		dpr, err := grpcClient.RetrieveIDByRoute(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

@@ -31,11 +31,11 @@ func (req retrieveStatusReq) validate() error {
 	return nil
 }
 
-type retrieveByRouteReq struct {
+type retrieveIDByRouteReq struct {
 	Route string
 }
 
-func (req retrieveByRouteReq) validate() error {
+func (req retrieveIDByRouteReq) validate() error {
 	if req.Route == "" {
 		return apiutil.ErrMissingRoute
 	}

domains/api/grpc/responses.go

@@ -7,9 +7,8 @@ type deleteUserRes struct {
 	deleted bool
 }
 
-type retrieveEntityRes struct {
-	id     string
-	status uint8
+type retrieveIDByRouteRes struct {
+	id string
 }
 
 type retrieveStatusRes struct {

domains/api/grpc/server.go

@@ -19,7 +19,7 @@ type domainsGrpcServer struct {
 	grpcDomainsV1.UnimplementedDomainsServiceServer
 	deleteUserFromDomains kitgrpc.Handler
 	retrieveStatus        kitgrpc.Handler
-	retrieveByRoute       kitgrpc.Handler
+	retrieveIDByRoute     kitgrpc.Handler
 }
 
 func NewDomainsServer(svc domains.Service) grpcDomainsV1.DomainsServiceServer {
@@ -34,10 +34,10 @@ func NewDomainsServer(svc domains.Service) grpcDomainsV1.DomainsServiceServer {
 			decodeRetrieveStatusRequest,
 			encodeRetrieveStatusResponse,
 		),
-		retrieveByRoute: kitgrpc.NewServer(
-			retrieveByRouteEndpoint(svc),
-			decodeRetrieveByRouteRequest,
-			encodeRetrieveByRouteResponse,
+		retrieveIDByRoute: kitgrpc.NewServer(
+			retrieveIDByRouteEndpoint(svc),
+			decodeRetrieveIDByRouteRequest,
+			encodeRetrieveIDByRouteResponse,
 		),
 	}
 }
@@ -89,27 +89,26 @@ func (s *domainsGrpcServer) RetrieveStatus(ctx context.Context, req *grpcCommonV
 	return res.(*grpcCommonV1.RetrieveEntityRes), nil
 }
 
-func decodeRetrieveByRouteRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
-	req := grpcReq.(*grpcCommonV1.RetrieveByRouteReq)
+func decodeRetrieveIDByRouteRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
+	req := grpcReq.(*grpcCommonV1.RetrieveIDByRouteReq)
 
-	return retrieveByRouteReq{
+	return retrieveIDByRouteReq{
 		Route: req.GetRoute(),
 	}, nil
 }
 
-func encodeRetrieveByRouteResponse(_ context.Context, grpcRes interface{}) (interface{}, error) {
-	res := grpcRes.(retrieveEntityRes)
+func encodeRetrieveIDByRouteResponse(_ context.Context, grpcRes interface{}) (interface{}, error) {
+	res := grpcRes.(retrieveIDByRouteRes)
 
 	return &grpcCommonV1.RetrieveEntityRes{
 		Entity: &grpcCommonV1.EntityBasic{
-			Id:     res.id,
-			Status: uint32(res.status),
+			Id: res.id,
 		},
 	}, nil
 }
 
-func (s *domainsGrpcServer) RetrieveByRoute(ctx context.Context, req *grpcCommonV1.RetrieveByRouteReq) (*grpcCommonV1.RetrieveEntityRes, error) {
-	_, res, err := s.retrieveByRoute.ServeGRPC(ctx, req)
+func (s *domainsGrpcServer) RetrieveIDByRoute(ctx context.Context, req *grpcCommonV1.RetrieveIDByRouteReq) (*grpcCommonV1.RetrieveEntityRes, error) {
+	_, res, err := s.retrieveIDByRoute.ServeGRPC(ctx, req)
 	if err != nil {
 		return nil, grpcapi.EncodeError(err)
 	}

domains/mocks/domains_client.go

@@ -126,8 +126,8 @@ func (_c *DomainsServiceClient_DeleteUserFromDomains_Call) RunAndReturn(run func
 	return _c
 }
 
-// RetrieveByRoute provides a mock function for the type DomainsServiceClient
-func (_mock *DomainsServiceClient) RetrieveByRoute(ctx context.Context, in *v10.RetrieveByRouteReq, opts ...grpc.CallOption) (*v10.RetrieveEntityRes, error) {
+// RetrieveIDByRoute provides a mock function for the type DomainsServiceClient
+func (_mock *DomainsServiceClient) RetrieveIDByRoute(ctx context.Context, in *v10.RetrieveIDByRouteReq, opts ...grpc.CallOption) (*v10.RetrieveEntityRes, error) {
 	var tmpRet mock.Arguments
 	if len(opts) > 0 {
 		tmpRet = _mock.Called(ctx, in, opts)
@@ -137,22 +137,22 @@ func (_mock *DomainsServiceClient) RetrieveByRoute(ctx context.Context, in *v10.
 	ret := tmpRet
 
 	if len(ret) == 0 {
-		panic("no return value specified for RetrieveByRoute")
+		panic("no return value specified for RetrieveIDByRoute")
 	}
 
 	var r0 *v10.RetrieveEntityRes
 	var r1 error
-	if returnFunc, ok := ret.Get(0).(func(context.Context, *v10.RetrieveByRouteReq, ...grpc.CallOption) (*v10.RetrieveEntityRes, error)); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *v10.RetrieveIDByRouteReq, ...grpc.CallOption) (*v10.RetrieveEntityRes, error)); ok {
 		return returnFunc(ctx, in, opts...)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, *v10.RetrieveByRouteReq, ...grpc.CallOption) *v10.RetrieveEntityRes); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, *v10.RetrieveIDByRouteReq, ...grpc.CallOption) *v10.RetrieveEntityRes); ok {
 		r0 = returnFunc(ctx, in, opts...)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).(*v10.RetrieveEntityRes)
 		}
 	}
-	if returnFunc, ok := ret.Get(1).(func(context.Context, *v10.RetrieveByRouteReq, ...grpc.CallOption) error); ok {
+	if returnFunc, ok := ret.Get(1).(func(context.Context, *v10.RetrieveIDByRouteReq, ...grpc.CallOption) error); ok {
 		r1 = returnFunc(ctx, in, opts...)
 	} else {
 		r1 = ret.Error(1)
@@ -160,29 +160,29 @@ func (_mock *DomainsServiceClient) RetrieveByRoute(ctx context.Context, in *v10.
 	return r0, r1
 }
 
-// DomainsServiceClient_RetrieveByRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveByRoute'
-type DomainsServiceClient_RetrieveByRoute_Call struct {
+// DomainsServiceClient_RetrieveIDByRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveIDByRoute'
+type DomainsServiceClient_RetrieveIDByRoute_Call struct {
 	*mock.Call
 }
 
-// RetrieveByRoute is a helper method to define mock.On call
+// RetrieveIDByRoute is a helper method to define mock.On call
 //   - ctx context.Context
-//   - in *v10.RetrieveByRouteReq
+//   - in *v10.RetrieveIDByRouteReq
 //   - opts ...grpc.CallOption
-func (_e *DomainsServiceClient_Expecter) RetrieveByRoute(ctx interface{}, in interface{}, opts ...interface{}) *DomainsServiceClient_RetrieveByRoute_Call {
-	return &DomainsServiceClient_RetrieveByRoute_Call{Call: _e.mock.On("RetrieveByRoute",
+func (_e *DomainsServiceClient_Expecter) RetrieveIDByRoute(ctx interface{}, in interface{}, opts ...interface{}) *DomainsServiceClient_RetrieveIDByRoute_Call {
+	return &DomainsServiceClient_RetrieveIDByRoute_Call{Call: _e.mock.On("RetrieveIDByRoute",
 		append([]interface{}{ctx, in}, opts...)...)}
 }
 
-func (_c *DomainsServiceClient_RetrieveByRoute_Call) Run(run func(ctx context.Context, in *v10.RetrieveByRouteReq, opts ...grpc.CallOption)) *DomainsServiceClient_RetrieveByRoute_Call {
+func (_c *DomainsServiceClient_RetrieveIDByRoute_Call) Run(run func(ctx context.Context, in *v10.RetrieveIDByRouteReq, opts ...grpc.CallOption)) *DomainsServiceClient_RetrieveIDByRoute_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
 			arg0 = args[0].(context.Context)
 		}
-		var arg1 *v10.RetrieveByRouteReq
+		var arg1 *v10.RetrieveIDByRouteReq
 		if args[1] != nil {
-			arg1 = args[1].(*v10.RetrieveByRouteReq)
+			arg1 = args[1].(*v10.RetrieveIDByRouteReq)
 		}
 		var arg2 []grpc.CallOption
 		var variadicArgs []grpc.CallOption
@@ -199,12 +199,12 @@ func (_c *DomainsServiceClient_RetrieveByRoute_Call) Run(run func(ctx context.Co
 	return _c
 }
 
-func (_c *DomainsServiceClient_RetrieveByRoute_Call) Return(retrieveEntityRes *v10.RetrieveEntityRes, err error) *DomainsServiceClient_RetrieveByRoute_Call {
+func (_c *DomainsServiceClient_RetrieveIDByRoute_Call) Return(retrieveEntityRes *v10.RetrieveEntityRes, err error) *DomainsServiceClient_RetrieveIDByRoute_Call {
 	_c.Call.Return(retrieveEntityRes, err)
 	return _c
 }
 
-func (_c *DomainsServiceClient_RetrieveByRoute_Call) RunAndReturn(run func(ctx context.Context, in *v10.RetrieveByRouteReq, opts ...grpc.CallOption) (*v10.RetrieveEntityRes, error)) *DomainsServiceClient_RetrieveByRoute_Call {
+func (_c *DomainsServiceClient_RetrieveIDByRoute_Call) RunAndReturn(run func(ctx context.Context, in *v10.RetrieveIDByRouteReq, opts ...grpc.CallOption) (*v10.RetrieveEntityRes, error)) *DomainsServiceClient_RetrieveIDByRoute_Call {
 	_c.Call.Return(run)
 	return _c
 }

domains/private/mocks/service.go

@@ -98,23 +98,23 @@ func (_c *Service_DeleteUserFromDomains_Call) RunAndReturn(run func(ctx context.
 	return _c
 }
 
-// RetrieveByRoute provides a mock function for the type Service
-func (_mock *Service) RetrieveByRoute(ctx context.Context, route string) (domains.Domain, error) {
+// RetrieveIDByRoute provides a mock function for the type Service
+func (_mock *Service) RetrieveIDByRoute(ctx context.Context, route string) (string, error) {
 	ret := _mock.Called(ctx, route)
 
 	if len(ret) == 0 {
-		panic("no return value specified for RetrieveByRoute")
+		panic("no return value specified for RetrieveIDByRoute")
 	}
 
-	var r0 domains.Domain
+	var r0 string
 	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) (string, error)); ok {
 		return returnFunc(ctx, route)
 	}
-	if returnFunc, ok := ret.Get(0).(func(context.Context, string) domains.Domain); ok {
+	if returnFunc, ok := ret.Get(0).(func(context.Context, string) string); ok {
 		r0 = returnFunc(ctx, route)
 	} else {
-		r0 = ret.Get(0).(domains.Domain)
+		r0 = ret.Get(0).(string)
 	}
 	if returnFunc, ok := ret.Get(1).(func(context.Context, string) error); ok {
 		r1 = returnFunc(ctx, route)
@@ -124,19 +124,19 @@ func (_mock *Service) RetrieveByRoute(ctx context.Context, route string) (domain
 	return r0, r1
 }
 
-// Service_RetrieveByRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveByRoute'
-type Service_RetrieveByRoute_Call struct {
+// Service_RetrieveIDByRoute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RetrieveIDByRoute'
+type Service_RetrieveIDByRoute_Call struct {
 	*mock.Call
 }
 
-// RetrieveByRoute is a helper method to define mock.On call
+// RetrieveIDByRoute is a helper method to define mock.On call
 //   - ctx context.Context
 //   - route string
-func (_e *Service_Expecter) RetrieveByRoute(ctx interface{}, route interface{}) *Service_RetrieveByRoute_Call {
-	return &Service_RetrieveByRoute_Call{Call: _e.mock.On("RetrieveByRoute", ctx, route)}
+func (_e *Service_Expecter) RetrieveIDByRoute(ctx interface{}, route interface{}) *Service_RetrieveIDByRoute_Call {
+	return &Service_RetrieveIDByRoute_Call{Call: _e.mock.On("RetrieveIDByRoute", ctx, route)}
 }
 
-func (_c *Service_RetrieveByRoute_Call) Run(run func(ctx context.Context, route string)) *Service_RetrieveByRoute_Call {
+func (_c *Service_RetrieveIDByRoute_Call) Run(run func(ctx context.Context, route string)) *Service_RetrieveIDByRoute_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		var arg0 context.Context
 		if args[0] != nil {
@@ -154,12 +154,12 @@ func (_c *Service_RetrieveByRoute_Call) Run(run func(ctx context.Context, route
 	return _c
 }
 
-func (_c *Service_RetrieveByRoute_Call) Return(domain domains.Domain, err error) *Service_RetrieveByRoute_Call {
-	_c.Call.Return(domain, err)
+func (_c *Service_RetrieveIDByRoute_Call) Return(s string, err error) *Service_RetrieveIDByRoute_Call {
+	_c.Call.Return(s, err)
 	return _c
 }
 
-func (_c *Service_RetrieveByRoute_Call) RunAndReturn(run func(ctx context.Context, route string) (domains.Domain, error)) *Service_RetrieveByRoute_Call {
+func (_c *Service_RetrieveIDByRoute_Call) RunAndReturn(run func(ctx context.Context, route string) (string, error)) *Service_RetrieveIDByRoute_Call {
 	_c.Call.Return(run)
 	return _c
 }

domains/private/service.go

@@ -16,7 +16,7 @@ const defLimit = 100
 type Service interface {
 	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)
+	RetrieveIDByRoute(ctx context.Context, route string) (string, error)
 }
 
 var _ Service = (*service)(nil)
@@ -70,18 +70,18 @@ func (svc service) DeleteUserFromDomains(ctx context.Context, id string) (err er
 	return nil
 }
 
-func (svc service) RetrieveByRoute(ctx context.Context, route string) (domains.Domain, error) {
+func (svc service) RetrieveIDByRoute(ctx context.Context, route string) (string, error) {
 	id, err := svc.cache.ID(ctx, route)
 	if err == nil {
-		return domains.Domain{ID: id}, nil
+		return id, nil
 	}
 	dom, err := svc.repo.RetrieveDomainByRoute(ctx, route)
 	if err != nil {
-		return domains.Domain{}, errors.Wrap(svcerr.ErrViewEntity, err)
+		return "", errors.Wrap(svcerr.ErrViewEntity, err)
 	}
 	if err := svc.cache.SaveID(ctx, route, dom.ID); err != nil {
-		return domains.Domain{}, errors.Wrap(svcerr.ErrUpdateEntity, err)
+		return "", errors.Wrap(svcerr.ErrUpdateEntity, err)
 	}
 
-	return domains.Domain{ID: dom.ID}, nil
+	return dom.ID, nil
 }

http/api/endpoint_test.go

@@ -261,7 +261,7 @@ func TestPublish(t *testing.T) {
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
 			clientsCall := clients.On("Authenticate", mock.Anything, &grpcClientsV1.AuthnReq{ClientSecret: tc.key}).Return(tc.authnRes, tc.authnErr)
-			domainsCall := domains.On("RetrieveByRoute", mock.Anything, mock.Anything).Return(&grpcCommonV1.RetrieveEntityRes{Entity: &grpcCommonV1.EntityBasic{Id: tc.domainID}}, nil)
+			domainsCall := domains.On("RetrieveIDByRoute", mock.Anything, mock.Anything).Return(&grpcCommonV1.RetrieveEntityRes{Entity: &grpcCommonV1.EntityBasic{Id: tc.domainID}}, nil)
 			channelsCall := channels.On("Authorize", mock.Anything, &grpcChannelsV1.AuthzReq{
 				DomainId:   tc.domainID,
 				ChannelId:  tc.chanID,

internal/proto/channels/v1/channels.proto

@@ -22,7 +22,7 @@ service ChannelsService {
   rpc RetrieveEntity(common.v1.RetrieveEntityReq)
     returns (common.v1.RetrieveEntityRes) {}
 
-  rpc RetrieveByRoute(common.v1.RetrieveByRouteReq)
+  rpc RetrieveIDByRoute(common.v1.RetrieveIDByRouteReq)
     returns (common.v1.RetrieveEntityRes) {}
 }
 

internal/proto/common/v1/common.proto

@@ -56,7 +56,7 @@ message Connection {
   uint32 type = 4;
 }
 
-message RetrieveByRouteReq{
+message RetrieveIDByRouteReq{
   string route = 1;
   string domain_id = 2;
 }

internal/proto/domains/v1/domains.proto

@@ -17,7 +17,7 @@ service DomainsService {
     returns (DeleteUserRes) {}
   rpc RetrieveStatus(common.v1.RetrieveEntityReq) 
     returns (common.v1.RetrieveEntityRes) {}
-  rpc RetrieveByRoute(common.v1.RetrieveByRouteReq)
+  rpc RetrieveIDByRoute(common.v1.RetrieveIDByRouteReq)
     returns (common.v1.RetrieveEntityRes) {}
 }
 

pkg/messaging/topics.go

@@ -201,7 +201,7 @@ func (r *resolver) resolveDomain(ctx context.Context, domain string) (string, bo
 	if validateUUID(domain) == nil {
 		return domain, false, nil
 	}
-	d, err := r.domains.RetrieveByRoute(ctx, &grpcCommonV1.RetrieveByRouteReq{
+	d, err := r.domains.RetrieveIDByRoute(ctx, &grpcCommonV1.RetrieveIDByRouteReq{
 		Route: domain,
 	})
 	if err != nil {
@@ -215,7 +215,7 @@ func (r *resolver) resolveChannel(ctx context.Context, channel, domainID string)
 	if validateUUID(channel) == nil {
 		return channel, false, nil
 	}
-	c, err := r.channels.RetrieveByRoute(ctx, &grpcCommonV1.RetrieveByRouteReq{
+	c, err := r.channels.RetrieveIDByRoute(ctx, &grpcCommonV1.RetrieveIDByRouteReq{
 		Route:    channel,
 		DomainId: domainID,
 	})

pkg/messaging/topics_test.go

@@ -584,12 +584,12 @@ func TestResolve(t *testing.T) {
 	}
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			domainsCall := domains.On("RetrieveByRoute", mock.Anything, &grpcCommonV1.RetrieveByRouteReq{Route: tc.domain}).Return(&grpcCommonV1.RetrieveEntityRes{
+			domainsCall := domains.On("RetrieveIDByRoute", mock.Anything, &grpcCommonV1.RetrieveIDByRouteReq{Route: tc.domain}).Return(&grpcCommonV1.RetrieveEntityRes{
 				Entity: &grpcCommonV1.EntityBasic{
 					Id: tc.domainID,
 				},
 			}, tc.domainsErr)
-			channelsCall := channels.On("RetrieveByRoute", mock.Anything, &grpcCommonV1.RetrieveByRouteReq{Route: tc.channel, DomainId: tc.domainID}).Return(&grpcCommonV1.RetrieveEntityRes{
+			channelsCall := channels.On("RetrieveIDByRoute", mock.Anything, &grpcCommonV1.RetrieveIDByRouteReq{Route: tc.channel, DomainId: tc.domainID}).Return(&grpcCommonV1.RetrieveEntityRes{
 				Entity: &grpcCommonV1.EntityBasic{
 					Id: tc.channelID,
 				},
@@ -694,12 +694,12 @@ func TestResolveTopic(t *testing.T) {
 	}
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			domainsCall := domains.On("RetrieveByRoute", mock.Anything, &grpcCommonV1.RetrieveByRouteReq{Route: tc.domain}).Return(&grpcCommonV1.RetrieveEntityRes{
+			domainsCall := domains.On("RetrieveIDByRoute", mock.Anything, &grpcCommonV1.RetrieveIDByRouteReq{Route: tc.domain}).Return(&grpcCommonV1.RetrieveEntityRes{
 				Entity: &grpcCommonV1.EntityBasic{
 					Id: tc.domainID,
 				},
 			}, tc.domainsErr)
-			channelsCall := channels.On("RetrieveByRoute", mock.Anything, &grpcCommonV1.RetrieveByRouteReq{Route: tc.channel, DomainId: tc.domainID}).Return(&grpcCommonV1.RetrieveEntityRes{
+			channelsCall := channels.On("RetrieveIDByRoute", mock.Anything, &grpcCommonV1.RetrieveIDByRouteReq{Route: tc.channel, DomainId: tc.domainID}).Return(&grpcCommonV1.RetrieveEntityRes{
 				Entity: &grpcCommonV1.EntityBasic{
 					Id: tc.channelID,
 				},
@@ -810,12 +810,12 @@ func TestParserPublishTopic(t *testing.T) {
 	}
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			domainsCall := domains.On("RetrieveByRoute", mock.Anything, &grpcCommonV1.RetrieveByRouteReq{Route: tc.domain}).Return(&grpcCommonV1.RetrieveEntityRes{
+			domainsCall := domains.On("RetrieveIDByRoute", mock.Anything, &grpcCommonV1.RetrieveIDByRouteReq{Route: tc.domain}).Return(&grpcCommonV1.RetrieveEntityRes{
 				Entity: &grpcCommonV1.EntityBasic{
 					Id: tc.domainID,
 				},
 			}, tc.domainsErr)
-			channelsCall := channels.On("RetrieveByRoute", mock.Anything, &grpcCommonV1.RetrieveByRouteReq{Route: tc.channel, DomainId: tc.domainID}).Return(&grpcCommonV1.RetrieveEntityRes{
+			channelsCall := channels.On("RetrieveIDByRoute", mock.Anything, &grpcCommonV1.RetrieveIDByRouteReq{Route: tc.channel, DomainId: tc.domainID}).Return(&grpcCommonV1.RetrieveEntityRes{
 				Entity: &grpcCommonV1.EntityBasic{
 					Id: tc.channelID,
 				},
@@ -920,12 +920,12 @@ func TestParserSubscribeTopic(t *testing.T) {
 	}
 	for _, tc := range cases {
 		t.Run(tc.desc, func(t *testing.T) {
-			domainsCall := domains.On("RetrieveByRoute", mock.Anything, &grpcCommonV1.RetrieveByRouteReq{Route: tc.domain}).Return(&grpcCommonV1.RetrieveEntityRes{
+			domainsCall := domains.On("RetrieveIDByRoute", mock.Anything, &grpcCommonV1.RetrieveIDByRouteReq{Route: tc.domain}).Return(&grpcCommonV1.RetrieveEntityRes{
 				Entity: &grpcCommonV1.EntityBasic{
 					Id: tc.domainID,
 				},
 			}, tc.domainsErr)
-			channelsCall := channels.On("RetrieveByRoute", mock.Anything, &grpcCommonV1.RetrieveByRouteReq{Route: tc.channel, DomainId: tc.domainID}).Return(&grpcCommonV1.RetrieveEntityRes{
+			channelsCall := channels.On("RetrieveIDByRoute", mock.Anything, &grpcCommonV1.RetrieveIDByRouteReq{Route: tc.channel, DomainId: tc.domainID}).Return(&grpcCommonV1.RetrieveEntityRes{
 				Entity: &grpcCommonV1.EntityBasic{
 					Id: tc.channelID,
 				},

pkg/sdk/message_test.go

@@ -187,8 +187,8 @@ func TestSendMessage(t *testing.T) {
 			authzCall := clientsGRPCClient.On("Authenticate", mock.Anything, mock.Anything).Return(tc.authRes, tc.authErr)
 			authnCall := channelsGRPCClient.On("Authorize", mock.Anything, mock.Anything).Return(&grpcChannelsV1.AuthzRes{Authorized: true}, nil)
 			svcCall := pub.On("Publish", mock.Anything, internalTopic, mock.Anything).Return(tc.svcErr)
-			domainsCall := domainsGRPCClient.On("RetrieveByRoute", mock.Anything, mock.Anything).Return(&grpcCommonV1.RetrieveEntityRes{Entity: &grpcCommonV1.EntityBasic{Id: tc.domainID}}, nil)
-			channelsCall := channelsGRPCClient.On("RetrieveByRoute", mock.Anything, mock.Anything).Return(&grpcCommonV1.RetrieveEntityRes{Entity: &grpcCommonV1.EntityBasic{Id: channelID}}, nil)
+			domainsCall := domainsGRPCClient.On("RetrieveIDByRoute", mock.Anything, mock.Anything).Return(&grpcCommonV1.RetrieveEntityRes{Entity: &grpcCommonV1.EntityBasic{Id: tc.domainID}}, nil)
+			channelsCall := channelsGRPCClient.On("RetrieveIDByRoute", mock.Anything, mock.Anything).Return(&grpcCommonV1.RetrieveEntityRes{Entity: &grpcCommonV1.EntityBasic{Id: channelID}}, nil)
 			err := mgsdk.SendMessage(context.Background(), tc.domainID, tc.topic, tc.msg, tc.secret)
 			assert.Equal(t, tc.err, err)
 			if tc.err == nil {