Refactor added saving auth token to redis when successfully logged in

src/internal/server/login_handler.go

@@ -12,11 +12,15 @@ func (s *Server) LoginHandlerFn(c *fiber.Ctx) error {
 		return s.Error(c, fiber.StatusBadRequest, "Error parsing input")
 	}
 
-	authSrv := service.NewAuthService(s.GetDatabase())
+	authSrv := service.NewAuthService(s.GetDatabase(), s.GetCache())
 
 	token, err := authSrv.Login(data.Username, data.Password)
 	if err != nil {
-		return fiber.NewError(fiber.StatusUnauthorized)
+		if err == service.ErrUnableToCacheToken {
+			return s.Error(c, fiber.StatusInternalServerError, err.Error())
+		}
+
+		return s.Error(c, fiber.StatusBadRequest, err.Error())
 	}
 
 	return c.JSON(&dto.AuthLoginResponseDTO{Token: token})

src/internal/server/register_handler.go

@@ -12,7 +12,7 @@ func (s *Server) RegisterHandlerFn(c *fiber.Ctx) error {
 		return s.Error(c, fiber.StatusBadRequest, "Error parsing input")
 	}
 
-	authSrv := service.NewAuthService(s.GetDatabase())
+	authSrv := service.NewAuthService(s.GetDatabase(), s.GetCache())
 
 	id, err := authSrv.Register(data.Email, data.Username, data.Password)
 	if err != nil {

src/internal/service/auth.go

@@ -3,40 +3,55 @@ package service
 import (
 	"context"
 	"errors"
+	"fmt"
 
 	db "git.ego.freeddns.org/egommerce/identity-service/pkg/database"
+	"github.com/go-redis/redis/v8"
 	"github.com/jackc/pgx/v5/pgxpool"
 )
 
 var (
 	AuthService *Auth
-	JWTService  *JWT
+	jwtSrv      *JWT
 
-	ErrLoginIncorrect = errors.New("login incorrect")
+	ErrLoginIncorrect     = errors.New("login incorrect")
+	ErrUnableToCacheToken = errors.New("unable to save token in cache")
 )
 
 func init() {
 }
 
 type Auth struct {
-	db *pgxpool.Pool
+	db    *pgxpool.Pool
+	cache *redis.Client
 }
 
-func NewAuthService(db *pgxpool.Pool) *Auth {
-	return &Auth{db: db}
+func NewAuthService(db *pgxpool.Pool, cache *redis.Client) *Auth {
+	return &Auth{
+		db:    db,
+		cache: cache,
+	}
 }
 
 func (a *Auth) Login(login, passwd string) (string, error) {
-	if login == "admin" && passwd == "secret" { // FIXME hardcoded
-		token, err := JWTService.CreateToken()
-		if err != nil {
-			return "", err
-		}
+	var id string
 
-		return token, nil
+	sql := `SELECT id FROM identity.users WHERE username=$1 AND password=$2 LIMIT 1`
+	err := a.db.QueryRow(context.Background(), sql, login, passwd).Scan(&id)
+	if err != nil {
+		// if err = db.NoRowsInQuerySet(err); err != nil { // FIXME NoRowsInQuerySet error detect
+		// 	return "", errors.New("no user found")
+		// }
+
+		return "", ErrLoginIncorrect
 	}
 
-	return "", ErrLoginIncorrect
+	token, _ := jwtSrv.CreateToken(id)
+	if err = a.saveTokenToCache(token, id); err != nil {
+		return "", ErrUnableToCacheToken
+	}
+
+	return token, nil
 }
 
 func (a *Auth) Register(email, login, passwd string) (string, error) {
@@ -48,8 +63,18 @@ func (a *Auth) Register(email, login, passwd string) (string, error) {
 		if err = db.IsDuplicatedRow(err); err != nil {
 			return "", errors.New("username/email is already taken")
 		}
+
 		return "", errors.New("Failed to create new user: " + err.Error())
 	}
 
 	return id, nil
 }
+
+func (a *Auth) saveTokenToCache(token, id string) error {
+	res := a.cache.Set(context.Background(), "auth:token:"+id, token, tokenExpireTime)
+	if err := res.Err(); err != nil {
+		fmt.Println("failed to save token in redis: ", err.Error())
+	}
+
+	return nil
+}

src/internal/service/jwt.go

@@ -10,24 +10,27 @@ import (
 )
 
 var (
-	tokenExpireTime int
-	tokenSecret     []byte
+	tokenExpireTime time.Duration
 )
 
 func init() {
-	tokenExpireTime, _ = strconv.Atoi(baseCnf.GetEnv("JWT_TOKEN_EXPIRE_TIME", "5"))
-	tokenSecret = []byte(baseCnf.GetEnv("JWT_SECRET_KEY", "B413IlIv9nKQfsMCXTE0Cteo4yHgUEfqaLfjg73sNlh")) // FIXME env: JWT_SECRET_KEY !!!
+	min, _ := strconv.Atoi(baseCnf.GetEnv("JWT_TOKEN_EXPIRE_TIME", "5"))
+	tokenExpireTime = time.Duration(int(time.Hour) * min)
 
-	JWTService = &JWT{tokenExpireTime, tokenSecret}
+	jwtSrv = &JWT{
+		tokenExpireTime,
+		[]byte(baseCnf.GetEnv("JWT_SECRET_KEY", "B413IlIv9nKQfsMCXTE0Cteo4yHgUEfqaLfjg73sNlh")),
+	}
 }
 
 type JWT struct {
-	tokenExpireTime int
+	tokenExpireTime time.Duration
 	tokenSecret     []byte
 }
 
-func (s *JWT) CreateToken() (string, error) {
+func (s *JWT) CreateToken(id string) (string, error) {
 	claims := &jwt.StandardClaims{
+		Id:        id,
 		ExpiresAt: time.Now().Add(time.Duration(s.tokenExpireTime) * time.Minute).Unix(),
 	}