refactor: move rpc mappper for shared

agent/internal/rpc/client.go

@@ -6,6 +6,7 @@ import (
 
 	pb "github.com/lorsanstand/HomeOps-Hub/api/gen/homeops"
 	"github.com/lorsanstand/HomeOps-Hub/shared/domain"
+	"github.com/lorsanstand/HomeOps-Hub/shared/mappers/rpc"
 	"google.golang.org/grpc"
 )
 
@@ -28,11 +29,11 @@ func (c *Connection) Hub() pb.HubClient {
 }
 
 func (c *Connection) RegisterAgent(ctx context.Context, RegisterData domain.RegisterAgentRequest) (domain.RegisterAgentResponse, error) {
-	ResponseData, err := c.Hub().RegisterAgent(ctx, new(domain.ToGRPCAgentRequest(RegisterData)))
+	ResponseData, err := c.Hub().RegisterAgent(ctx, new(rpc.ToGRPCAgentRequest(RegisterData)))
 	if err != nil {
 		return domain.RegisterAgentResponse{}, fmt.Errorf("send register agent: %w", err)
 	}
-	response, err := domain.ToDomainAgentResponse(ResponseData)
+	response, err := rpc.ToDomainAgentResponse(ResponseData)
 	if err != nil {
 		return domain.RegisterAgentResponse{}, fmt.Errorf("casting response: %w", err)
 	}

hub/internal/rpc/server.go

@@ -7,6 +7,7 @@ import (
 	pb "github.com/lorsanstand/HomeOps-Hub/api/gen/homeops"
 	"github.com/lorsanstand/HomeOps-Hub/hub/internal/service/connection_manager"
 	"github.com/lorsanstand/HomeOps-Hub/shared/domain"
+	"github.com/lorsanstand/HomeOps-Hub/shared/mappers/rpc"
 	"github.com/rs/zerolog"
 	"google.golang.org/grpc"
 	"google.golang.org/protobuf/types/known/emptypb"
@@ -46,7 +47,7 @@ func (h *HubHandler) Ping(ctx context.Context, _ *emptypb.Empty) (*pb.PongRespon
 
 func (h *HubHandler) RegisterAgent(ctx context.Context, request *pb.RegisterAgentRequest) (*pb.RegisterAgentResponse, error) {
 	h.log.Debug().Str("agentID", request.AgentId).Str("agentName", request.AgentName).Msg("register agent request received")
-	data, err := domain.ToDomainAgentRequest(request)
+	data, err := rpc.ToDomainAgentRequest(request)
 	if err != nil {
 		h.log.Error().Err(err).Msg("failed to casting request")
 		return &pb.RegisterAgentResponse{}, ErrFailedRegister
@@ -54,10 +55,10 @@ func (h *HubHandler) RegisterAgent(ctx context.Context, request *pb.RegisterAgen
 	resp, err := h.hub.RegisterAgent(ctx, data)
 	if err != nil {
 		h.log.Error().Err(err).Msg("failed register agent")
-		return domain.ToGRPCAgentResponse(resp), ErrFailedRegister
+		return rpc.ToGRPCAgentResponse(resp), ErrFailedRegister
 	}
 	h.log.Info().Str("agentID", resp.AgentID).Msg("register agent request completed")
-	return domain.ToGRPCAgentResponse(resp), nil
+	return rpc.ToGRPCAgentResponse(resp), nil
 }
 
 func (h *HubHandler) StreamConnection(stream grpc.BidiStreamingServer[pb.AgentEvent, pb.ServerCommandRequest]) error {

shared/mappers/rpc/mapper.go

@@ -1,21 +1,22 @@
-package domain
+package rpc
 
 import (
 	"fmt"
 
 	pb "github.com/lorsanstand/HomeOps-Hub/api/gen/homeops"
+	"github.com/lorsanstand/HomeOps-Hub/shared/domain"
 )
 
-func ToDomainAgentRequest(request *pb.RegisterAgentRequest) (RegisterAgentRequest, error) {
+func ToDomainAgentRequest(request *pb.RegisterAgentRequest) (domain.RegisterAgentRequest, error) {
 	if request == nil {
-		return RegisterAgentRequest{}, fmt.Errorf("request is empty")
+		return domain.RegisterAgentRequest{}, fmt.Errorf("request is empty")
 	}
 
-	return RegisterAgentRequest{
+	return domain.RegisterAgentRequest{
 		AgentVersion: request.Version,
 		AgentID:      request.AgentId,
 		AgentName:    request.AgentName,
-		Host: HostInfo{
+		Host: domain.HostInfo{
 			System:   request.Host.System,
 			Hostname: request.Host.Hostname,
 			Arch:     request.Host.Arch,
@@ -24,26 +25,26 @@ func ToDomainAgentRequest(request *pb.RegisterAgentRequest) (RegisterAgentReques
 	}, nil
 }
 
-func ToDomainAgentResponse(response *pb.RegisterAgentResponse) (RegisterAgentResponse, error) {
+func ToDomainAgentResponse(response *pb.RegisterAgentResponse) (domain.RegisterAgentResponse, error) {
 	if response == nil {
-		return RegisterAgentResponse{}, fmt.Errorf("request is empty")
+		return domain.RegisterAgentResponse{}, fmt.Errorf("request is empty")
 	}
 
-	return RegisterAgentResponse{
+	return domain.RegisterAgentResponse{
 		AgentID:   response.AgentId,
 		Heartbeat: int(response.HeartbeatIntervalSecond),
 	}, nil
 }
 
-func ToDomainCapabilities(capability []*pb.Capability) []Capability {
+func ToDomainCapabilities(capability []*pb.Capability) []domain.Capability {
-	var caps []Capability
+	var caps []domain.Capability
 
 	for _, capa := range capability {
 		if capa == nil {
 			continue
 		}
 
-		caps = append(caps, Capability{
+		caps = append(caps, domain.Capability{
 			Name:      capa.Name,
 			Version:   capa.Version,
 			Reason:    capa.Reason,
@@ -54,7 +55,7 @@ func ToDomainCapabilities(capability []*pb.Capability) []Capability {
 	return caps
 }
 
-func ToGRPCAgentRequest(request RegisterAgentRequest) pb.RegisterAgentRequest {
+func ToGRPCAgentRequest(request domain.RegisterAgentRequest) pb.RegisterAgentRequest {
 	return pb.RegisterAgentRequest{
 		AgentId:   request.AgentID,
 		AgentName: request.AgentName,
@@ -68,11 +69,11 @@ func ToGRPCAgentRequest(request RegisterAgentRequest) pb.RegisterAgentRequest {
 	}
 }
 
-func ToGRPCAgentResponse(response RegisterAgentResponse) *pb.RegisterAgentResponse {
+func ToGRPCAgentResponse(response domain.RegisterAgentResponse) *pb.RegisterAgentResponse {
 	return &pb.RegisterAgentResponse{AgentId: response.AgentID, HeartbeatIntervalSecond: int64(response.Heartbeat)}
 }
 
-func ToGRPCCapability(caps []Capability) []*pb.Capability {
+func ToGRPCCapability(caps []domain.Capability) []*pb.Capability {
 	var capability []*pb.Capability
 	for _, capi := range caps {
 		capability = append(capability, &pb.Capability{