refactor: extract shared BasePartyClient to reduce duplicate gRPC connection code (#400)

* feat(clients): extract shared BasePartyClient to shared/pkg/clients

Introduces BasePartyClient infrastructure to reduce code duplication
between tenant and current-account services when connecting to the
Party service. The shared client handles common gRPC connection setup,
configuration validation, timeout defaults, tracer interceptors, and
context propagation (correlation ID and organization ID).

* refactor(tenant): use shared BasePartyClient for Party service communication

Refactor tenant service's PartyClient to embed shared BasePartyClient,
removing ~75 lines of duplicate connection setup code. The tenant-specific
error handling for RegisterParty (AlreadyExists, InvalidArgument, Unavailable,
DeadlineExceeded) is preserved while common gRPC infrastructure is delegated
to the shared package.

* refactor(current-account): use shared BasePartyClient for party service communication

Refactor current-account service's PartyClient to embed BasePartyClient from
shared/pkg/clients, removing ~70 lines of duplicate connection setup code.

Changes:
- Remove local PartyClientConfig struct (use sharedclients.PartyClientConfig)
- Remove local connection fields and constructor logic (delegate to BasePartyClient)
- Remove local Close() method (inherited from BasePartyClient via embedding)
- Update GetParty to use PrepareContext() for context preparation
- Update tests to use sharedclients.PartyClientConfig and ErrPartyServiceNameRequired
- Update main.go and grpc_service.go to use sharedclients.PartyClientConfig

The service-specific errors (ErrPartyNotFound, ErrPartyNotActive) and business
logic (ValidateParty status check) remain in the current-account package.

Part of tech debt cleanup task 19 - Extract shared PartyClient.

---------

Co-authored-by: Ben Coombs <bjcoombs@users.noreply.github.com>

Author: bjcoombs

services/current-account/clients/party_client.go

@@ -1,136 +1,78 @@
+// Package clients provides gRPC client wrappers for external service communication.
 package clients
 
 import (
 	"context"
 	"errors"
 	"fmt"
-	"time"
 
 	partyv1 "github.com/meridianhub/meridian/api/proto/meridian/party/v1"
 	sharedclients "github.com/meridianhub/meridian/shared/pkg/clients"
-	platformgrpc "github.com/meridianhub/meridian/shared/pkg/grpc"
-	"github.com/meridianhub/meridian/shared/platform/observability"
-	"google.golang.org/grpc"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
 )
 
-// Party validation errors
+// Party validation errors.
 var (
-	// ErrPartyNotFound is returned when the requested party does not exist
+	// ErrPartyNotFound is returned when the requested party does not exist.
 	ErrPartyNotFound = errors.New("party not found")
-	// ErrPartyNotActive is returned when the party exists but is not in ACTIVE status
+	// ErrPartyNotActive is returned when the party exists but is not in ACTIVE status.
 	ErrPartyNotActive = errors.New("party not active")
-	// ErrPartyServiceNameRequired is returned when ServiceName is not provided
-	ErrPartyServiceNameRequired = errors.New("ServiceName is required for party client")
 )
 
-// PartyClient defines the interface for communicating with the Party service
+// PartyClient defines the interface for communicating with the Party service.
 //
 // The Party service manages party reference data (customers, counterparties,
 // legal entities). CurrentAccount uses this service to validate party ownership
 // before account operations.
 type PartyClient interface {
-	// ValidateParty checks if a party exists and is active
+	// ValidateParty checks if a party exists and is active.
 	//
 	// Returns nil if the party exists and has ACTIVE status.
 	// Returns ErrPartyNotFound if the party does not exist.
 	// Returns ErrPartyNotActive if the party exists but is not ACTIVE.
 	ValidateParty(ctx context.Context, partyID string) error
 
-	// GetParty retrieves full party details by ID
+	// GetParty retrieves full party details by ID.
 	//
 	// Returns the party data if found, or an error if not found.
 	GetParty(ctx context.Context, partyID string) (*partyv1.Party, error)
 
-	// Close terminates the client connection gracefully
+	// Close terminates the client connection gracefully.
 	Close() error
 }
 
-// PartyGRPCClient implements PartyClient using gRPC
+// PartyGRPCClient implements PartyClient using gRPC.
+//
+// This client embeds the shared BasePartyClient for connection management
+// and adds current-account-specific error handling for party validation operations.
 type PartyGRPCClient struct {
-	conn    *grpc.ClientConn
-	client  partyv1.PartyServiceClient
-	tracer  *observability.Tracer
-	timeout time.Duration
-}
-
-// PartyClientConfig holds configuration for the Party client
-type PartyClientConfig struct {
-	// ServiceName is the Kubernetes service name (e.g., "party").
-	// Required. Enables DNS-based client-side load balancing via pkg/platform/grpc.
-	// The client will connect to dns:///party.<namespace>.svc.cluster.local:<port>
-	// and use round_robin load balancing across all pod IPs.
-	ServiceName string
-
-	// Namespace is the Kubernetes namespace (e.g., "default", "production")
-	// Defaults to "default" if not specified or empty.
-	Namespace string
-
-	// Port is the service port number
-	// Party service uses port 50055 (configured in services/party/k8s/service.yaml)
-	Port int
-
-	// Timeout is the default timeout for RPC calls
-	// If not specified, defaults to 30 seconds
-	Timeout time.Duration
-
-	// Tracer is an optional observability tracer for distributed tracing
-	// If provided, the client will automatically propagate trace context
-	Tracer *observability.Tracer
-
-	// DialOptions allows custom gRPC dial options
-	DialOptions []grpc.DialOption
+	*sharedclients.BasePartyClient
 }
 
 // NewPartyClient creates a new Party gRPC client using DNS-based load balancing.
 //
 // Example:
 //
-//	config := &clients.PartyClientConfig{
+//	config := &sharedclients.PartyClientConfig{
 //	    ServiceName: "party",
 //	    Namespace:   "default",
 //	    Port:        50055,
 //	    Timeout:     30 * time.Second,
-//	    Tracer:      tracer,
 //	}
-func NewPartyClient(cfg *PartyClientConfig) (*PartyGRPCClient, error) {
-	if cfg.ServiceName == "" {
-		return nil, ErrPartyServiceNameRequired
-	}
-
-	if cfg.Timeout == 0 {
-		cfg.Timeout = 30 * time.Second
-	}
-
-	dialOpts := cfg.DialOptions
-
-	if cfg.Tracer != nil {
-		dialOpts = append(dialOpts,
-			grpc.WithUnaryInterceptor(cfg.Tracer.UnaryClientInterceptor()),
-			grpc.WithStreamInterceptor(cfg.Tracer.StreamClientInterceptor()),
-		)
-	}
-
-	conn, err := platformgrpc.NewClient(context.Background(), platformgrpc.ClientConfig{
-		ServiceName: cfg.ServiceName,
-		Namespace:   cfg.Namespace,
-		Port:        cfg.Port,
-		DialOptions: dialOpts,
-	})
+//	client, err := clients.NewPartyClient(config)
+func NewPartyClient(cfg *sharedclients.PartyClientConfig) (*PartyGRPCClient, error) {
+	base, err := sharedclients.NewBasePartyClient(cfg)
 	if err != nil {
-		return nil, fmt.Errorf("failed to create gRPC connection: %w", err)
+		return nil, err
 	}
 
 	return &PartyGRPCClient{
-		conn:    conn,
-		client:  partyv1.NewPartyServiceClient(conn),
-		tracer:  cfg.Tracer,
-		timeout: cfg.Timeout,
+		BasePartyClient: base,
 	}, nil
 }
 
-// ValidateParty checks if a party exists and is active
+// ValidateParty checks if a party exists and is active.
 func (c *PartyGRPCClient) ValidateParty(ctx context.Context, partyID string) error {
 	party, err := c.GetParty(ctx, partyID)
 	if err != nil {
@@ -144,15 +86,12 @@ func (c *PartyGRPCClient) ValidateParty(ctx context.Context, partyID string) err
 	return nil
 }
 
-// GetParty retrieves full party details by ID
+// GetParty retrieves full party details by ID.
 func (c *PartyGRPCClient) GetParty(ctx context.Context, partyID string) (*partyv1.Party, error) {
-	ctx, cancel := sharedclients.WithTimeout(ctx, c.timeout)
+	ctx, cancel := c.PrepareContext(ctx)
 	defer cancel()
 
-	ctx = sharedclients.PropagateCorrelationID(ctx)
-	ctx = sharedclients.PropagateOrganization(ctx)
-
-	resp, err := c.client.RetrieveParty(ctx, &partyv1.RetrievePartyRequest{
+	resp, err := c.Client().RetrieveParty(ctx, &partyv1.RetrievePartyRequest{
 		PartyId: partyID,
 	})
 	if err != nil {
@@ -165,13 +104,3 @@ func (c *PartyGRPCClient) GetParty(ctx context.Context, partyID string) (*partyv
 
 	return resp.Party, nil
 }
-
-// Close terminates the gRPC connection
-func (c *PartyGRPCClient) Close() error {
-	if c.conn != nil {
-		if err := c.conn.Close(); err != nil {
-			return fmt.Errorf("failed to close party client connection: %w", err)
-		}
-	}
-	return nil
-}

services/current-account/clients/party_client_test.go

@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/meridianhub/meridian/services/current-account/clients"
+	sharedclients "github.com/meridianhub/meridian/shared/pkg/clients"
 	"github.com/meridianhub/meridian/shared/platform/observability"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -14,23 +15,23 @@ import (
 func TestNewPartyClient_RequiresServiceName(t *testing.T) {
 	t.Parallel()
 
-	cfg := &clients.PartyClientConfig{
+	cfg := &sharedclients.PartyClientConfig{
 		Namespace: "default",
 		Port:      50055,
 		Timeout:   10 * time.Second,
 	}
 
 	client, err := clients.NewPartyClient(cfg)
 
-	assert.ErrorIs(t, err, clients.ErrPartyServiceNameRequired)
+	assert.ErrorIs(t, err, sharedclients.ErrPartyServiceNameRequired)
 	assert.Nil(t, client)
 }
 
 // TestNewPartyClient_Success verifies client creation with valid configuration
 func TestNewPartyClient_Success(t *testing.T) {
 	t.Parallel()
 
-	cfg := &clients.PartyClientConfig{
+	cfg := &sharedclients.PartyClientConfig{
 		ServiceName: "party",
 		Namespace:   "default",
 		Port:        50055,
@@ -48,7 +49,7 @@ func TestNewPartyClient_Success(t *testing.T) {
 func TestNewPartyClient_DefaultTimeout(t *testing.T) {
 	t.Parallel()
 
-	cfg := &clients.PartyClientConfig{
+	cfg := &sharedclients.PartyClientConfig{
 		ServiceName: "party",
 		Namespace:   "default",
 		Port:        50055,
@@ -67,7 +68,7 @@ func TestNewPartyClient_CustomTimeout(t *testing.T) {
 	t.Parallel()
 
 	customTimeout := 5 * time.Minute
-	cfg := &clients.PartyClientConfig{
+	cfg := &sharedclients.PartyClientConfig{
 		ServiceName: "party",
 		Namespace:   "default",
 		Port:        50055,
@@ -86,7 +87,7 @@ func TestNewPartyClient_WithTracer(t *testing.T) {
 	t.Parallel()
 
 	tracer := &observability.Tracer{}
-	cfg := &clients.PartyClientConfig{
+	cfg := &sharedclients.PartyClientConfig{
 		ServiceName: "party",
 		Namespace:   "default",
 		Port:        50055,
@@ -105,7 +106,7 @@ func TestNewPartyClient_WithTracer(t *testing.T) {
 func TestNewPartyClient_DefaultNamespace(t *testing.T) {
 	t.Parallel()
 
-	cfg := &clients.PartyClientConfig{
+	cfg := &sharedclients.PartyClientConfig{
 		ServiceName: "party",
 		Namespace:   "", // Should default to "default"
 		Port:        50055,
@@ -123,7 +124,7 @@ func TestNewPartyClient_DefaultNamespace(t *testing.T) {
 func TestNewPartyClient_CustomNamespace(t *testing.T) {
 	t.Parallel()
 
-	cfg := &clients.PartyClientConfig{
+	cfg := &sharedclients.PartyClientConfig{
 		ServiceName: "party",
 		Namespace:   "production",
 		Port:        50055,
@@ -141,7 +142,7 @@ func TestNewPartyClient_CustomNamespace(t *testing.T) {
 func TestPartyClient_Close_Success(t *testing.T) {
 	t.Parallel()
 
-	cfg := &clients.PartyClientConfig{
+	cfg := &sharedclients.PartyClientConfig{
 		ServiceName: "party",
 		Namespace:   "default",
 		Port:        50055,
@@ -161,7 +162,7 @@ func TestPartyClient_Close_Success(t *testing.T) {
 func TestPartyClient_Close_Multiple(t *testing.T) {
 	t.Parallel()
 
-	cfg := &clients.PartyClientConfig{
+	cfg := &sharedclients.PartyClientConfig{
 		ServiceName: "party",
 		Namespace:   "default",
 		Port:        50055,
@@ -185,7 +186,7 @@ func TestPartyClient_Close_Multiple(t *testing.T) {
 func TestNewPartyClient_NilTracer(t *testing.T) {
 	t.Parallel()
 
-	cfg := &clients.PartyClientConfig{
+	cfg := &sharedclients.PartyClientConfig{
 		ServiceName: "party",
 		Namespace:   "default",
 		Port:        50055,

services/current-account/cmd/main.go

@@ -441,7 +441,7 @@ func createServiceWithClients(
 	)
 
 	// Create Party client with DNS-based load balancing
-	partyGRPCClient, err := clients.NewPartyClient(&clients.PartyClientConfig{
+	partyGRPCClient, err := clients.NewPartyClient(&sharedclients.PartyClientConfig{
 		ServiceName: "party",
 		Namespace:   namespace,
 		Port:        50055, // Party service port (see services/party/k8s/service.yaml)

services/current-account/service/grpc_service.go

@@ -228,7 +228,7 @@ func NewServiceWithClients(config Config) (*Service, error) {
 	// Create Party client (optional - nil client provides backward compatibility)
 	var resilientPartyClient clients.PartyClient
 	if config.PartyServiceName != "" {
-		partyGRPCClient, err := clients.NewPartyClient(&clients.PartyClientConfig{
+		partyGRPCClient, err := clients.NewPartyClient(&sharedclients.PartyClientConfig{
 			ServiceName: config.PartyServiceName,
 			Namespace:   config.Namespace,
 			Port:        config.PartyPort,