Files
mtusi2026lab2/internal/service/auth.go
T

106 lines
2.5 KiB
Go

package service
import (
"context"
"errors"
"time"
"mtusi2026-messenger/internal/credentials"
"mtusi2026-messenger/internal/db"
"mtusi2026-messenger/internal/model"
"mtusi2026-messenger/internal/postgres"
"github.com/google/uuid"
)
var (
ErrInvalidCredentials = errors.New("invalid credentials")
ErrUnauthorized = errors.New("unauthorized")
)
type authQueries interface {
CreateSession(ctx context.Context, arg db.CreateSessionParams) error
DeleteSession(ctx context.Context, tokenHash string) (int64, error)
GetSessionUserID(ctx context.Context, tokenHash string) (uuid.UUID, error)
GetUserByUsername(ctx context.Context, username string) (db.User, error)
}
type AuthService struct {
q authQueries
sessionTTL time.Duration
}
func NewAuthService(q authQueries, sessionTTL time.Duration) *AuthService {
return &AuthService{
q: q,
sessionTTL: sessionTTL,
}
}
var dummyHash, _ = credentials.HashPassword("dummy-password-for-timing")
func (s *AuthService) Login(ctx context.Context, username, plain string) (model.Session, error) {
user, err := s.q.GetUserByUsername(ctx, username)
if postgres.IsNotFound(err) {
_ = credentials.VerifyPassword(dummyHash, plain)
return model.Session{}, ErrInvalidCredentials
}
if err != nil {
return model.Session{}, err
}
if err := credentials.VerifyPassword(user.PasswordHash, plain); err != nil {
if errors.Is(err, credentials.ErrPasswordMismatch) {
return model.Session{}, ErrInvalidCredentials
}
return model.Session{}, err
}
token := credentials.NewToken()
expiresAt := time.Now().UTC().Add(s.sessionTTL)
err = s.q.CreateSession(ctx, db.CreateSessionParams{
TokenHash: credentials.HashToken(token),
UserID: user.ID,
ExpiresAt: expiresAt,
})
if err != nil {
return model.Session{}, err
}
return model.Session{
Token: token,
ExpiresAt: expiresAt,
User: model.User{
ID: user.ID,
Username: user.Username,
DisplayName: user.DisplayName,
CreatedAt: user.CreatedAt.UTC(),
},
}, nil
}
func (s *AuthService) Authenticate(ctx context.Context, token string) (uuid.UUID, error) {
userID, err := s.q.GetSessionUserID(ctx, credentials.HashToken(token))
if postgres.IsNotFound(err) {
return uuid.Nil, ErrUnauthorized
}
if err != nil {
return uuid.Nil, err
}
return userID, nil
}
func (s *AuthService) Logout(ctx context.Context, token string) error {
n, err := s.q.DeleteSession(ctx, credentials.HashToken(token))
if err != nil {
return err
}
if n == 0 {
return ErrUnauthorized
}
return nil
}