feat(auth): structural refactor

Author: shamikkarkhanis

internal/auth/adapters/persistence.go

@@ -30,3 +30,7 @@ func (r *UserRepoAdapter) CreateUser(ctx context.Context, arg database.CreateUse
 func (r *UserRepoAdapter) GetUserByID(ctx context.Context, uid uuid.UUID) (database.User, error) {
 	return r.queries.GetUserByID(ctx, uid)
 }
+
+func (r *UserRepoAdapter) CreateBotToken(ctx context.Context, arg database.CreateBotTokenParams) (database.BotToken, error) {
+	return r.queries.CreateBotToken(ctx, arg)
+}

internal/auth/ports/interfaces.go

@@ -22,6 +22,11 @@ type UserRepo interface {
 	GetUserByID(ctx context.Context, uid uuid.UUID) (database.User, error)
 }
 
+// BotRepo defines the interface for bot token persistence
+type BotRepo interface {
+	CreateBotToken(ctx context.Context, arg database.CreateBotTokenParams) (database.BotToken, error)
+}
+
 // TokenProvider defines the interface for token generation
 type TokenProvider interface {
 	GenerateToken(user database.User) (string, error)

internal/auth/service/service.go

@@ -1,26 +1,131 @@
 package service
 
 import (
+	"context"
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"time"
+
 	"github.com/capyrpi/api/internal/auth/ports"
+	"github.com/capyrpi/api/internal/database"
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgtype"
+	"golang.org/x/crypto/bcrypt"
 )
 
+type AuthResult struct {
+	User  database.User
+	Token string
+}
+
+type BotTokenResult struct {
+	Token    database.BotToken
+	RawToken string
+}
+
 type AuthService struct {
 	userRepo      ports.UserRepo
+	botRepo       ports.BotRepo
 	tokenProvider ports.TokenProvider
 	googleAuth    ports.OAuthProvider
 	microsoftAuth ports.OAuthProvider
 }
 
 func NewAuthService(
 	userRepo ports.UserRepo,
+	botRepo ports.BotRepo,
 	tokenProvider ports.TokenProvider,
 	googleAuth ports.OAuthProvider,
 	microsoftAuth ports.OAuthProvider,
 ) *AuthService {
 	return &AuthService{
 		userRepo:      userRepo,
+		botRepo:       botRepo,
 		tokenProvider: tokenProvider,
 		googleAuth:    googleAuth,
 		microsoftAuth: microsoftAuth,
 	}
 }
+
+func (s *AuthService) HandleOAuthCallback(ctx context.Context, providerName string, code string) (*AuthResult, error) {
+	var provider ports.OAuthProvider
+	switch providerName {
+	case "google":
+		provider = s.googleAuth
+	case "microsoft":
+		provider = s.microsoftAuth
+	default:
+		return nil, errors.New("invalid provider")
+	}
+
+	userInfo, err := provider.ExchangeCode(ctx, code)
+	if err != nil {
+		return nil, err
+	}
+
+	pgEmail := pgtype.Text{String: userInfo.Email, Valid: true}
+	user, err := s.userRepo.GetUserByEmail(ctx, pgEmail)
+	if err != nil {
+		if err != pgx.ErrNoRows {
+			return nil, err
+		}
+
+		// Create user if not exists
+		user, err = s.userRepo.CreateUser(ctx, database.CreateUserParams{
+			FirstName:     userInfo.FirstName,
+			LastName:      userInfo.LastName,
+			PersonalEmail: pgEmail,
+			SchoolEmail:   pgtype.Text{Valid: false},
+			Role:          database.NullUserRole{UserRole: database.UserRoleStudent, Valid: true},
+		})
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	token, err := s.tokenProvider.GenerateToken(user)
+	if err != nil {
+		return nil, err
+	}
+
+	return &AuthResult{User: user, Token: token}, nil
+}
+
+func (s *AuthService) GenerateBotToken(ctx context.Context, name string, createdBy uuid.UUID, expiresAt *time.Time) (*BotTokenResult, error) {
+	rawToken, err := generateSecureToken(32)
+	if err != nil {
+		return nil, err
+	}
+
+	hashedToken, err := bcrypt.GenerateFromPassword([]byte(rawToken), bcrypt.DefaultCost)
+	if err != nil {
+		return nil, err
+	}
+
+	pgExpiresAt := pgtype.Timestamp{Valid: false}
+	if expiresAt != nil {
+		pgExpiresAt = pgtype.Timestamp{Time: *expiresAt, Valid: true}
+	}
+
+	token, err := s.botRepo.CreateBotToken(ctx, database.CreateBotTokenParams{
+		TokenHash: string(hashedToken),
+		Name:      name,
+		CreatedBy: createdBy,
+		ExpiresAt: pgExpiresAt,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	return &BotTokenResult{Token: token, RawToken: rawToken}, nil
+}
+
+func generateSecureToken(length int) (string, error) {
+	bytes := make([]byte, length)
+	if _, err := rand.Read(bytes); err != nil {
+		return "", err
+	}
+	return hex.EncodeToString(bytes), nil
+}

internal/auth/service/service_test.go

@@ -1,15 +1,180 @@
 package service_test
 
 import (
+	"context"
+	"errors"
 	"testing"
+	"time"
 
+	"github.com/capyrpi/api/internal/auth/ports"
 	"github.com/capyrpi/api/internal/auth/service"
+	"github.com/capyrpi/api/internal/database"
+	"github.com/google/uuid"
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgtype"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
 )
 
-func TestAuthService(t *testing.T) {
-	// Just a dummy test to ensure the package imports are correct
-	// and the struct can be instantiated (with nil dependencies for now)
-	svc := service.NewAuthService(nil, nil, nil, nil)
-	assert.NotNil(t, svc)
+// Mocks
+type MockUserRepo struct {
+	mock.Mock
+}
+
+func (m *MockUserRepo) GetUserByEmail(ctx context.Context, email pgtype.Text) (database.User, error) {
+	args := m.Called(ctx, email)
+	return args.Get(0).(database.User), args.Error(1)
+}
+
+func (m *MockUserRepo) CreateUser(ctx context.Context, arg database.CreateUserParams) (database.User, error) {
+	args := m.Called(ctx, arg)
+	return args.Get(0).(database.User), args.Error(1)
+}
+
+func (m *MockUserRepo) GetUserByID(ctx context.Context, uid uuid.UUID) (database.User, error) {
+	args := m.Called(ctx, uid)
+	return args.Get(0).(database.User), args.Error(1)
+}
+
+type MockBotRepo struct {
+	mock.Mock
+}
+
+func (m *MockBotRepo) CreateBotToken(ctx context.Context, arg database.CreateBotTokenParams) (database.BotToken, error) {
+	args := m.Called(ctx, arg)
+	return args.Get(0).(database.BotToken), args.Error(1)
+}
+
+type MockTokenProvider struct {
+	mock.Mock
+}
+
+func (m *MockTokenProvider) GenerateToken(user database.User) (string, error) {
+	args := m.Called(user)
+	return args.String(0), args.Error(1)
+}
+
+type MockOAuthProvider struct {
+	mock.Mock
+}
+
+func (m *MockOAuthProvider) GetAuthURL(state string) string {
+	args := m.Called(state)
+	return args.String(0)
+}
+
+func (m *MockOAuthProvider) ExchangeCode(ctx context.Context, code string) (*ports.UserInfo, error) {
+	args := m.Called(ctx, code)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).(*ports.UserInfo), args.Error(1)
+}
+
+func TestAuthService_HandleOAuthCallback(t *testing.T) {
+	// Setup
+	mockUserRepo := new(MockUserRepo)
+	mockBotRepo := new(MockBotRepo)
+	mockTokenProvider := new(MockTokenProvider)
+	mockGoogle := new(MockOAuthProvider)
+	mockMicrosoft := new(MockOAuthProvider)
+
+	svc := service.NewAuthService(mockUserRepo, mockBotRepo, mockTokenProvider, mockGoogle, mockMicrosoft)
+	ctx := context.Background()
+
+	t.Run("Success existing user", func(t *testing.T) {
+		email := "test@example.com"
+		userInfo := &ports.UserInfo{Email: email, FirstName: "John", LastName: "Doe"}
+		user := database.User{
+			Uid:           uuid.New(),
+			FirstName:     "John",
+			LastName:      "Doe",
+			PersonalEmail: pgtype.Text{String: email, Valid: true},
+		}
+		token := "jwt-token"
+
+		mockGoogle.On("ExchangeCode", ctx, "auth-code").Return(userInfo, nil)
+		mockUserRepo.On("GetUserByEmail", ctx, pgtype.Text{String: email, Valid: true}).Return(user, nil)
+		mockTokenProvider.On("GenerateToken", user).Return(token, nil)
+
+		res, err := svc.HandleOAuthCallback(ctx, "google", "auth-code")
+
+		assert.NoError(t, err)
+		assert.Equal(t, user, res.User)
+		assert.Equal(t, token, res.Token)
+		mockGoogle.AssertExpectations(t)
+		mockUserRepo.AssertExpectations(t)
+		mockTokenProvider.AssertExpectations(t)
+	})
+
+	t.Run("Success new user", func(t *testing.T) {
+		email := "new@example.com"
+		userInfo := &ports.UserInfo{Email: email, FirstName: "Jane", LastName: "Doe"}
+		user := database.User{
+			Uid:           uuid.New(),
+			FirstName:     "Jane",
+			LastName:      "Doe",
+			PersonalEmail: pgtype.Text{String: email, Valid: true},
+		}
+		token := "jwt-token"
+
+		mockGoogle.On("ExchangeCode", ctx, "new-code").Return(userInfo, nil)
+		mockUserRepo.On("GetUserByEmail", ctx, pgtype.Text{String: email, Valid: true}).Return(database.User{}, pgx.ErrNoRows)
+		mockUserRepo.On("CreateUser", ctx, mock.AnythingOfType("database.CreateUserParams")).Return(user, nil)
+		mockTokenProvider.On("GenerateToken", user).Return(token, nil)
+
+		res, err := svc.HandleOAuthCallback(ctx, "google", "new-code")
+
+		assert.NoError(t, err)
+		assert.Equal(t, user, res.User)
+		assert.Equal(t, token, res.Token)
+	})
+
+	t.Run("Invalid provider", func(t *testing.T) {
+		res, err := svc.HandleOAuthCallback(ctx, "invalid", "code")
+		assert.Error(t, err)
+		assert.Nil(t, res)
+	})
+
+	t.Run("Exchange code error", func(t *testing.T) {
+		mockGoogle.On("ExchangeCode", ctx, "bad-code").Return(nil, errors.New("exchange error"))
+		res, err := svc.HandleOAuthCallback(ctx, "google", "bad-code")
+		assert.Error(t, err)
+		assert.Nil(t, res)
+	})
+}
+
+func TestAuthService_GenerateBotToken(t *testing.T) {
+	// Setup
+	mockUserRepo := new(MockUserRepo)
+	mockBotRepo := new(MockBotRepo)
+	mockTokenProvider := new(MockTokenProvider)
+	mockGoogle := new(MockOAuthProvider)
+	mockMicrosoft := new(MockOAuthProvider)
+
+	svc := service.NewAuthService(mockUserRepo, mockBotRepo, mockTokenProvider, mockGoogle, mockMicrosoft)
+	ctx := context.Background()
+	uid := uuid.New()
+
+	t.Run("Success", func(t *testing.T) {
+		name := "My Bot"
+		botToken := database.BotToken{
+			TokenID:   uuid.New(),
+			Name:      name,
+			CreatedBy: uid,
+			CreatedAt: pgtype.Timestamp{Time: time.Now(), Valid: true},
+		}
+
+		// Use mock.MatchedBy to check arguments
+		mockBotRepo.On("CreateBotToken", ctx, mock.MatchedBy(func(arg database.CreateBotTokenParams) bool {
+			return arg.Name == name && arg.CreatedBy == uid && len(arg.TokenHash) > 0
+		})).Return(botToken, nil)
+
+		res, err := svc.GenerateBotToken(ctx, name, uid, nil)
+
+		assert.NoError(t, err)
+		assert.Equal(t, botToken, res.Token)
+		assert.NotEmpty(t, res.RawToken)
+		mockBotRepo.AssertExpectations(t)
+	})
 }