refactored jwt related to struct.

Author: alexmay23

default_use_case.go

@@ -4,24 +4,11 @@ import (
 	"context"
 	"errors"
 	"fmt"
-	"github.com/golang-jwt/jwt/v5"
-
 	"github.com/techpro-studio/goauthlib/oauth"
 	"github.com/techpro-studio/gohttplib"
 	"math/rand"
 )
 
-type Config struct {
-	blinder                    string
-	signingMethod              jwt.SigningMethod
-	signingKey                 any
-	softDeleteUserIfNoServices bool
-}
-
-func NewConfig(blinder string, signingMethod jwt.SigningMethod, signingKey any, softDeleteUserIfNoServices bool) *Config {
-	return &Config{blinder: blinder, signingMethod: signingMethod, signingKey: signingKey, softDeleteUserIfNoServices: softDeleteUserIfNoServices}
-}
-
 type OTPDelivery interface {
 	SendOTP(ctx context.Context, destination, otp string) error
 }
@@ -58,19 +45,24 @@ func (d DoNothingUseCaseCallback) OnRemoveServiceFrom(ctx context.Context, user
 }
 
 type DefaultUseCase struct {
-	SocialProviders map[string]oauth.SocialProvider
-	Deliveries      map[string]OTPDelivery
-	repository      Repository
-	callback        UserCaseCallback
-	config          Config
+	SocialProviders            map[string]oauth.SocialProvider
+	Deliveries                 map[string]OTPDelivery
+	repository                 Repository
+	callback                   UserCaseCallback
+	jwtConfig                  JWTConfig
+	softDeleteUserIfNoServices bool
+}
+
+func (useCase *DefaultUseCase) SetSoftDeleteUserIfNoServices(softDeleteUserIfNoServices bool) {
+	useCase.softDeleteUserIfNoServices = softDeleteUserIfNoServices
 }
 
 func (useCase *DefaultUseCase) UpsertUser(ctx context.Context, entity AuthorizationEntity, info map[string]any) (*Response, error) {
 	user, err := useCase.repository.UpsertForEntity(ctx, entity, info)
 	if err != nil {
 		return nil, err
 	}
-	token, err := GenerateTokenFromModel(*user, useCase.config.blinder, useCase.config.signingMethod, useCase.config.signingKey)
+	token, err := useCase.jwtConfig.GenerateTokenFromModel(*user)
 	if err != nil {
 		return nil, err
 	}
@@ -93,8 +85,8 @@ func (useCase *DefaultUseCase) RegisterOTPDelivery(key string, delivery OTPDeliv
 	useCase.Deliveries[key] = delivery
 }
 
-func NewDefaultUseCase(repository Repository, config Config, callback UserCaseCallback) *DefaultUseCase {
-	return &DefaultUseCase{repository: repository, SocialProviders: map[string]oauth.SocialProvider{}, Deliveries: map[string]OTPDelivery{}, config: config, callback: callback}
+func NewDefaultUseCase(repository Repository, config JWTConfig, callback UserCaseCallback) *DefaultUseCase {
+	return &DefaultUseCase{repository: repository, SocialProviders: map[string]oauth.SocialProvider{}, Deliveries: map[string]OTPDelivery{}, jwtConfig: config, callback: callback}
 }
 
 func (useCase *DefaultUseCase) RegisterSocialProvider(key string, provider oauth.SocialProvider) {
@@ -169,7 +161,7 @@ func (useCase *DefaultUseCase) getInfoFromProvider(ctx context.Context, payload
 }
 
 func (useCase *DefaultUseCase) generateResponseFor(usr *User, userInfo map[string]interface{}) (*Response, error) {
-	jsonWebToken, err := GenerateTokenFromModel(*usr, useCase.config.blinder, useCase.config.signingMethod, useCase.config.signingKey)
+	jsonWebToken, err := useCase.jwtConfig.GenerateTokenFromModel(*usr)
 	if err != nil {
 		return nil, gohttplib.HTTP400(err.Error())
 	}
@@ -189,7 +181,7 @@ func (useCase *DefaultUseCase) VerifyDelete(ctx context.Context, user User, code
 }
 
 func (useCase *DefaultUseCase) ForceDelete(ctx context.Context, user User) error {
-	useCase.repository.RemoveService(ctx, user.ID, useCase.config.softDeleteUserIfNoServices, func(ctx context.Context, userId string) error {
+	useCase.repository.RemoveService(ctx, user.ID, useCase.softDeleteUserIfNoServices, func(ctx context.Context, userId string) error {
 		return useCase.callback.OnRemoveServiceFrom(ctx, &user)
 	})
 	for _, entity := range user.Entities {

functions.go jwt.gofunctions.go renamed to jwt.go

@@ -12,8 +12,44 @@ import (
 	"strings"
 )
 
-func GenerateTokenFromModel(model User, blinder string, signingMethod jwt.SigningMethod, signingKey any) (string, error) {
-	hash := GenerateTokenHash(model, blinder)
+type JWTConfig struct {
+	signingMethod   jwt.SigningMethod
+	signingKey      any
+	verificationKey any
+	blinder         string
+}
+
+func (config JWTConfig) SigningMethod() jwt.SigningMethod {
+	return config.signingMethod
+}
+
+func (config JWTConfig) SigningKey() any {
+	return config.signingKey
+}
+
+func (config JWTConfig) VerificationKey() any {
+	return config.verificationKey
+}
+
+func (config JWTConfig) Blinder() string {
+	return config.blinder
+}
+
+func (config JWTConfig) Copy() JWTConfig {
+	return JWTConfig{
+		signingMethod:   config.signingMethod,
+		signingKey:      config.signingKey,
+		verificationKey: config.verificationKey,
+		blinder:         config.blinder,
+	}
+}
+
+func NewJWTConfig(signingMethod jwt.SigningMethod, signingKey any, verificationKey any, blinder string) *JWTConfig {
+	return &JWTConfig{signingMethod: signingMethod, signingKey: signingKey, verificationKey: verificationKey, blinder: blinder}
+}
+
+func (config JWTConfig) GenerateTokenFromModel(model User) (string, error) {
+	hash := GenerateTokenHash(model, config.blinder)
 
 	claims := struct {
 		Hash string `json:"hash"`
@@ -25,21 +61,21 @@ func GenerateTokenFromModel(model User, blinder string, signingMethod jwt.Signin
 			Issuer: "auth",
 		},
 	}
-	tokenObj := jwt.NewWithClaims(signingMethod, claims)
+	tokenObj := jwt.NewWithClaims(config.signingMethod, claims)
 
-	token, err := tokenObj.SignedString(signingKey)
+	token, err := tokenObj.SignedString(config.signingKey)
 	if err != nil {
 		return "", err
 	}
 	return token, nil
 }
 
-func GetClaimsFromToken(token string, currentSigningMethod jwt.SigningMethod, currentSigningKey any) (map[string]any, error) {
+func (config JWTConfig) GetClaimsFromToken(token string) (map[string]any, error) {
 	tokenObj, err := jwt.ParseWithClaims(token, &jwt.MapClaims{}, func(token *jwt.Token) (any, error) {
-		if token.Method.Alg() != currentSigningMethod.Alg() {
+		if token.Method.Alg() != config.signingMethod.Alg() {
 			return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
 		}
-		return currentSigningKey, nil
+		return config.verificationKey, nil
 	})
 
 	if err != nil {
@@ -79,7 +115,7 @@ func GenerateTokenHash(model User, blinder string) string {
 	return hex.EncodeToString(sha.Sum(nil))
 }
 
-func SafeExtractUserIdFromHeader(h http.Header, currentSigningMethod jwt.SigningMethod, signingKey any) (string, error) {
+func (config JWTConfig) SafeExtractUserIdFromHeader(h http.Header) (string, error) {
 	// Check if Authorization header exists
 	authHeader, ok := h["Authorization"]
 	if !ok || len(authHeader) == 0 {
@@ -94,7 +130,7 @@ func SafeExtractUserIdFromHeader(h http.Header, currentSigningMethod jwt.Signing
 
 	token := tokenParts[1]
 
-	claims, err := GetClaimsFromToken(token, currentSigningMethod, signingKey)
+	claims, err := config.GetClaimsFromToken(token)
 	if err != nil {
 		return "", err
 	}
@@ -112,8 +148,8 @@ func SafeExtractUserIdFromHeader(h http.Header, currentSigningMethod jwt.Signing
 	return userIdFromJwt, nil
 }
 
-func GetValidUserFromToken(token string, config Config) (*User, error) {
-	claims, err := GetClaimsFromToken(token, config.signingMethod, config.signingKey)
+func (config JWTConfig) GetValidUserFromToken(token string) (*User, error) {
+	claims, err := config.GetClaimsFromToken(token)
 	if err != nil {
 		return nil, err
 	}