first commit

internal/services/auth.go

@@ -0,0 +1,90 @@
+package services
+
+import (
+	"errors"
+	"studioj/boilerplate_go/internal/models"
+	"studioj/boilerplate_go/internal/repositories"
+	"time"
+
+	"github.com/google/uuid"
+	"golang.org/x/crypto/bcrypt"
+)
+
+type authService struct {
+	userRepository  repositories.UserRepository
+	tokenRepository repositories.TokenRepository
+}
+
+type AuthService interface {
+	Register(*models.RegisterRequest) (*models.User, error)
+	Login(*models.LoginRequest) (*models.User, error)
+	CreateToken(string) (*models.Token, error)
+}
+
+func NewAuthService(userRepository repositories.UserRepository, tokenRepository repositories.TokenRepository) AuthService {
+	return &authService{
+		userRepository:  userRepository,
+		tokenRepository: tokenRepository,
+	}
+}
+
+func (s *authService) Register(request *models.RegisterRequest) (*models.User, error) {
+	hash, err := bcrypt.GenerateFromPassword([]byte(request.Password), 10)
+	if err != nil {
+		return nil, errors.New("fail to hash password")
+	}
+
+	// Create the user
+	newUser := models.User{
+		ID:       uuid.NewString(),
+		Username: request.Username,
+		Password: string(hash),
+	}
+
+	user, err := s.userRepository.Create(&newUser)
+	if err != nil {
+		return nil, errors.New("fail to create user")
+	}
+
+	return user, err
+}
+
+func (s *authService) Login(request *models.LoginRequest) (*models.User, error) {
+	user, err := s.userRepository.FindByUsername(request.Username)
+	if err != nil || user == nil {
+		return nil, errors.New("invalid user or password")
+	}
+
+	err = bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(request.Password))
+	if err != nil {
+		return nil, errors.New("invalid user or password")
+	}
+	return user, nil
+}
+
+func (s *authService) CreateToken(user_id string) (*models.Token, error) {
+	tokenExpiredAt := time.Now().Add(time.Hour * 24 * 30)
+	accessToken, err := s.tokenRepository.Generate(user_id, tokenExpiredAt.Unix())
+	if err != nil {
+		return nil, err
+	}
+
+	refreshExpiredAt := time.Now().Add(time.Hour * 24 * 90)
+	refreshToken, err := s.tokenRepository.Generate(user_id, refreshExpiredAt.Unix())
+	if err != nil {
+		return nil, err
+	}
+
+	newToken := &models.Token{
+		ID:           uuid.NewString(),
+		UserID:       user_id,
+		Token:        accessToken,
+		RefreshToken: refreshToken,
+		Status:       "valid",
+		ExpireAt:     tokenExpiredAt,
+	}
+
+	token, err := s.tokenRepository.Create(newToken)
+
+	return token, err
+}

internal/services/token.go

@@ -0,0 +1,115 @@
+package services
+
+import (
+	"fmt"
+	"strings"
+
+	config "studioj/boilerplate_go/configs"
+	"studioj/boilerplate_go/internal/models"
+	"studioj/boilerplate_go/internal/repositories"
+
+	"github.com/golang-jwt/jwt/v5"
+)
+
+type tokenService struct {
+	repository repositories.TokenRepository
+}
+
+type TokenService interface {
+	Find(string) (*models.Token, error)
+	Create(*models.Token) (*models.Token, error)
+	Update(*models.Token) (*models.Token, error)
+	Delete(string) error
+
+	Generate(string, int64) (string, error)
+	Verify(tokenString string) (*jwt.Token, error)
+
+	GetJwtToken(string) (*jwt.Token, error)
+	ExtractTokenString(string) string
+	VerifyTokenString(string) (*jwt.Token, error)
+	ValidToken(*jwt.Token) (bool, error)
+}
+
+func NewTokenService(repository repositories.TokenRepository) TokenService {
+	return &tokenService{
+		repository: repository,
+	}
+}
+
+func (s *tokenService) Find(id string) (*models.Token, error) {
+	return s.repository.Find(id)
+}
+
+func (s *tokenService) Create(token *models.Token) (*models.Token, error) {
+	return s.repository.Create(token)
+}
+
+func (s *tokenService) Update(token *models.Token) (*models.Token, error) {
+	return s.repository.Update(token)
+}
+
+func (s *tokenService) Delete(id string) error {
+	return s.repository.Delete(id)
+}
+
+func (s *tokenService) Verify(tokenString string) (*jwt.Token, error) {
+	jwtToken, err := jwt.Parse(tokenString, func(jwtToken *jwt.Token) (interface{}, error) {
+		if _, ok := jwtToken.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, fmt.Errorf("unexpected signing method: %v", jwtToken.Header["alg"])
+		}
+		return []byte(config.SECRET_KEY), nil
+	})
+
+	return jwtToken, err
+}
+
+func (s *tokenService) Generate(user_id string, expire_at int64) (string, error) {
+	claims := jwt.MapClaims{}
+	claims["authorized"] = true
+	claims["sub"] = user_id
+	claims["exp"] = expire_at
+	at := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	token, err := at.SignedString([]byte(config.SECRET_KEY))
+
+	return token, err
+}
+
+func (s *tokenService) GetJwtToken(tokenString string) (*jwt.Token, error) {
+	jwtToken, err := jwt.Parse(tokenString, func(jwtToken *jwt.Token) (interface{}, error) {
+		if _, ok := jwtToken.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, fmt.Errorf("unexpected signing method: %v", jwtToken.Header["alg"])
+		}
+		return []byte(config.SECRET_KEY), nil
+	})
+	return jwtToken, err
+}
+
+func (s *tokenService) ExtractTokenString(authorization string) string {
+	strArr := strings.Split(authorization, " ")
+	if len(strArr) == 2 {
+		return strArr[1]
+	}
+	return ""
+}
+
+func (s *tokenService) VerifyTokenString(tokenString string) (*jwt.Token, error) {
+	jwtToken, err := jwt.Parse(tokenString, func(jwtToken *jwt.Token) (interface{}, error) {
+		if _, ok := jwtToken.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, fmt.Errorf("unexpected signing method: %v", jwtToken.Header["alg"])
+		}
+		return []byte(config.SECRET_KEY), nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	return jwtToken, nil
+}
+
+func (s *tokenService) ValidToken(jwtToken *jwt.Token) (bool, error) {
+	if jwtToken == nil {
+		return false, fmt.Errorf("no token")
+	}
+	return jwtToken.Valid, nil
+}

internal/services/user.go

@@ -0,0 +1,38 @@
+package services
+
+import (
+	"studioj/boilerplate_go/internal/models"
+	"studioj/boilerplate_go/internal/repositories"
+)
+
+type userService struct {
+	repository      repositories.UserRepository
+	tokenRepository repositories.TokenRepository
+}
+
+type UserService interface {
+	FindByID(string) (*models.User, error)
+	FindByUsername(string) (*models.User, error)
+	Create(*models.User) (*models.User, error)
+}
+
+func NewUserService(repository repositories.UserRepository, tokenRepository repositories.TokenRepository) UserService {
+	return &userService{
+		repository:      repository,
+		tokenRepository: tokenRepository,
+	}
+}
+
+func (s *userService) FindByID(id string) (*models.User, error) {
+	return s.repository.FindByID(id)
+}
+
+func (s *userService) FindByUsername(username string) (*models.User, error) {
+	return s.repository.FindByUsername(username)
+}
+
+func (s *userService) Create(user *models.User) (*models.User, error) {
+	result, err := s.repository.Create(user)
+
+	return result, err
+}