goplt/internal/client/grpc/auth_client.go

// Package grpc provides gRPC client implementations for service clients.
package grpc

import (
	"context"
	"fmt"

	"git.dcentral.systems/toolz/goplt/pkg/registry"
	"git.dcentral.systems/toolz/goplt/pkg/services"
	"google.golang.org/grpc"
	"google.golang.org/grpc/credentials/insecure"
)

// AuthClient implements AuthServiceClient using gRPC.
// This is a stub implementation - will be fully implemented when proto files are generated in Phase 4.
type AuthClient struct {
	registry registry.ServiceRegistry
	// conn will be set when proto files are available
	// conn *grpc.ClientConn
}

// NewAuthClient creates a new gRPC client for the Auth Service.
func NewAuthClient(reg registry.ServiceRegistry) (services.AuthServiceClient, error) {
	return &AuthClient{
		registry: reg,
	}, nil
}

// Login authenticates a user and returns access and refresh tokens.
func (c *AuthClient) Login(ctx context.Context, email, password string) (*services.TokenResponse, error) {
	// TODO: Implement when proto files are generated
	return nil, fmt.Errorf("not implemented: proto files not yet generated")
}

// RefreshToken refreshes an access token using a refresh token.
func (c *AuthClient) RefreshToken(ctx context.Context, refreshToken string) (*services.TokenResponse, error) {
	// TODO: Implement when proto files are generated
	return nil, fmt.Errorf("not implemented: proto files not yet generated")
}

// ValidateToken validates a JWT token and returns the token claims.
func (c *AuthClient) ValidateToken(ctx context.Context, token string) (*services.TokenClaims, error) {
	// TODO: Implement when proto files are generated
	return nil, fmt.Errorf("not implemented: proto files not yet generated")
}

// Logout invalidates a refresh token.
func (c *AuthClient) Logout(ctx context.Context, refreshToken string) error {
	// TODO: Implement when proto files are generated
	return fmt.Errorf("not implemented: proto files not yet generated")
}

// connectToService discovers and connects to a service instance.
func connectToService(ctx context.Context, reg registry.ServiceRegistry, serviceName string) (*grpc.ClientConn, error) {
	instances, err := reg.Discover(ctx, serviceName)
	if err != nil {
		return nil, fmt.Errorf("failed to discover service %s: %w", serviceName, err)
	}

	if len(instances) == 0 {
		return nil, fmt.Errorf("no instances found for service %s", serviceName)
	}

	// Use the first healthy instance (load balancing can be added later)
	instance := instances[0]
	address := fmt.Sprintf("%s:%d", instance.Address, instance.Port)

	// Create gRPC connection
	conn, err := grpc.NewClient(address, grpc.WithTransportCredentials(insecure.NewCredentials()))
	if err != nil {
		return nil, fmt.Errorf("failed to connect to %s at %s: %w", serviceName, address, err)
	}

	return conn, nil
}