feat: [#495] Centralize Error Messages in Framework (PR#2)

auth/auth.go

@@ -1,7 +1,6 @@
 package auth
 
 import (
-	"errors"
 	"strings"
 	"time"
 
@@ -14,6 +13,7 @@ import (
 	"github.com/goravel/framework/contracts/config"
 	"github.com/goravel/framework/contracts/database/orm"
 	"github.com/goravel/framework/contracts/http"
+	"github.com/goravel/framework/errors"
 	"github.com/goravel/framework/support/carbon"
 	"github.com/goravel/framework/support/database"
 )
@@ -58,16 +58,16 @@ func (a *Auth) Guard(name string) contractsauth.Auth {
 func (a *Auth) User(user any) error {
 	auth, ok := a.ctx.Value(ctxKey).(Guards)
 	if !ok || auth[a.guard] == nil {
-		return ErrorParseTokenFirst
+		return errors.ErrAuthParseTokenFirst
 	}
 	if auth[a.guard].Claims == nil {
-		return ErrorParseTokenFirst
+		return errors.ErrAuthParseTokenFirst
 	}
 	if auth[a.guard].Claims.Key == "" {
-		return ErrorInvalidKey
+		return errors.ErrAuthInvalidKey
 	}
 	if auth[a.guard].Token == "" {
-		return ErrorTokenExpired
+		return errors.ErrAuthTokenExpired
 	}
 	if err := a.orm.Query().FindOrFail(user, clause.Eq{Column: clause.PrimaryColumn, Value: auth[a.guard].Claims.Key}); err != nil {
 		return err
@@ -79,10 +79,10 @@ func (a *Auth) User(user any) error {
 func (a *Auth) Id() (string, error) {
 	auth, ok := a.ctx.Value(ctxKey).(Guards)
 	if !ok || auth[a.guard] == nil {
-		return "", ErrorParseTokenFirst
+		return "", errors.ErrAuthParseTokenFirst
 	}
 	if auth[a.guard].Token == "" {
-		return "", ErrorTokenExpired
+		return "", errors.ErrAuthTokenExpired
 	}
 
 	return auth[a.guard].Claims.Key, nil
@@ -91,10 +91,10 @@ func (a *Auth) Id() (string, error) {
 func (a *Auth) Parse(token string) (*contractsauth.Payload, error) {
 	token = strings.ReplaceAll(token, "Bearer ", "")
 	if a.cache == nil {
-		return nil, errors.New("cache support is required")
+		return nil, errors.ErrCacheSupportRequired.SetModule(errors.ModuleAuth)
 	}
 	if a.tokenIsDisabled(token) {
-		return nil, ErrorTokenDisabled
+		return nil, errors.ErrAuthTokenDisabled
 	}
 
 	jwtSecret := a.config.GetString("jwt.secret")
@@ -107,7 +107,7 @@ func (a *Auth) Parse(token string) (*contractsauth.Payload, error) {
 		if errors.Is(err, jwt.ErrTokenExpired) && tokenClaims != nil {
 			claims, ok := tokenClaims.Claims.(*Claims)
 			if !ok {
-				return nil, ErrorInvalidClaims
+				return nil, errors.ErrAuthInvalidClaims
 			}
 
 			a.makeAuthContext(claims, "")
@@ -117,18 +117,18 @@ func (a *Auth) Parse(token string) (*contractsauth.Payload, error) {
 				Key:      claims.Key,
 				ExpireAt: claims.ExpiresAt.Local(),
 				IssuedAt: claims.IssuedAt.Local(),
-			}, ErrorTokenExpired
+			}, errors.ErrAuthTokenExpired
 		}
 
-		return nil, ErrorInvalidToken
+		return nil, errors.ErrAuthInvalidToken
 	}
 	if tokenClaims == nil || !tokenClaims.Valid {
-		return nil, ErrorInvalidToken
+		return nil, errors.ErrAuthInvalidToken
 	}
 
 	claims, ok := tokenClaims.Claims.(*Claims)
 	if !ok {
-		return nil, ErrorInvalidClaims
+		return nil, errors.ErrAuthInvalidClaims
 	}
 
 	a.makeAuthContext(claims, token)
@@ -144,7 +144,7 @@ func (a *Auth) Parse(token string) (*contractsauth.Payload, error) {
 func (a *Auth) Login(user any) (token string, err error) {
 	id := database.GetID(user)
 	if id == nil {
-		return "", ErrorNoPrimaryKeyField
+		return "", errors.ErrAuthNoPrimaryKeyField
 	}
 
 	return a.LoginUsingID(id)
@@ -153,7 +153,7 @@ func (a *Auth) Login(user any) (token string, err error) {
 func (a *Auth) LoginUsingID(id any) (token string, err error) {
 	jwtSecret := a.config.GetString("jwt.secret")
 	if jwtSecret == "" {
-		return "", ErrorEmptySecret
+		return "", errors.ErrAuthEmptySecret
 	}
 
 	nowTime := carbon.Now()
@@ -165,7 +165,7 @@ func (a *Auth) LoginUsingID(id any) (token string, err error) {
 	expireTime := nowTime.AddMinutes(ttl).StdTime()
 	key := cast.ToString(id)
 	if key == "" {
-		return "", ErrorInvalidKey
+		return "", errors.ErrAuthInvalidKey
 	}
 	claims := Claims{
 		key,
@@ -191,10 +191,10 @@ func (a *Auth) LoginUsingID(id any) (token string, err error) {
 func (a *Auth) Refresh() (token string, err error) {
 	auth, ok := a.ctx.Value(ctxKey).(Guards)
 	if !ok || auth[a.guard] == nil {
-		return "", ErrorParseTokenFirst
+		return "", errors.ErrAuthParseTokenFirst
 	}
 	if auth[a.guard].Claims == nil {
-		return "", ErrorParseTokenFirst
+		return "", errors.ErrAuthParseTokenFirst
 	}
 
 	nowTime := carbon.Now()
@@ -206,7 +206,7 @@ func (a *Auth) Refresh() (token string, err error) {
 
 	expireTime := carbon.FromStdTime(auth[a.guard].Claims.ExpiresAt.Time).AddMinutes(refreshTtl)
 	if nowTime.Gt(expireTime) {
-		return "", ErrorRefreshTimeExceeded
+		return "", errors.ErrAuthRefreshTimeExceeded
 	}
 
 	return a.LoginUsingID(auth[a.guard].Claims.Key)
@@ -219,13 +219,13 @@ func (a *Auth) Logout() error {
 	}
 
 	if a.cache == nil {
-		return errors.New("cache support is required")
+		return errors.ErrCacheSupportRequired.SetModule(errors.ModuleAuth)
 	}
 
 	ttl := a.config.GetInt("jwt.ttl")
 	if ttl == 0 {
 		if ok := a.cache.Forever(getDisabledCacheKey(auth[a.guard].Token), true); !ok {
-			return errors.New("cache forever failed")
+			return errors.ErrCacheForeverFailed.SetModule(errors.ModuleAuth)
 		}
 	} else {
 		if err := a.cache.Put(getDisabledCacheKey(auth[a.guard].Token),

auth/auth_test.go

@@ -2,7 +2,6 @@ package auth
 
 import (
 	"context"
-	"errors"
 	"sync"
 	"testing"
 	"time"
@@ -15,6 +14,7 @@ import (
 	authcontract "github.com/goravel/framework/contracts/auth"
 	"github.com/goravel/framework/contracts/http"
 	"github.com/goravel/framework/database/orm"
+	"github.com/goravel/framework/errors"
 	cachemock "github.com/goravel/framework/mocks/cache"
 	configmock "github.com/goravel/framework/mocks/config"
 	ormmock "github.com/goravel/framework/mocks/database/orm"
@@ -117,7 +117,7 @@ func (s *AuthTestSuite) TestLoginUsingID_EmptySecret() {
 
 	token, err := s.auth.LoginUsingID(1)
 	s.Empty(token)
-	s.ErrorIs(err, ErrorEmptySecret)
+	s.ErrorIs(err, errors.ErrAuthEmptySecret)
 
 	s.mockConfig.AssertExpectations(s.T())
 }
@@ -128,7 +128,7 @@ func (s *AuthTestSuite) TestLoginUsingID_InvalidKey() {
 
 	token, err := s.auth.LoginUsingID("")
 	s.Empty(token)
-	s.ErrorIs(err, ErrorInvalidKey)
+	s.ErrorIs(err, errors.ErrAuthInvalidKey)
 
 	s.mockConfig.AssertExpectations(s.T())
 }
@@ -198,7 +198,7 @@ func (s *AuthTestSuite) TestLogin_ErrorModel() {
 	errorUser.Name = "Goravel"
 	token, err := s.auth.Login(&errorUser)
 	s.Empty(token)
-	s.EqualError(err, "the primaryKey field was not found in the model, set primaryKey like orm.Model")
+	s.EqualError(err, errors.ErrAuthNoPrimaryKeyField.Error())
 }
 
 func (s *AuthTestSuite) TestLogin_NoPrimaryKey() {
@@ -212,7 +212,7 @@ func (s *AuthTestSuite) TestLogin_NoPrimaryKey() {
 	user.Name = "Goravel"
 	token, err := s.auth.Login(&user)
 	s.Empty(token)
-	s.ErrorIs(err, ErrorNoPrimaryKeyField)
+	s.ErrorIs(err, errors.ErrAuthNoPrimaryKeyField)
 }
 
 func (s *AuthTestSuite) TestParse_TokenDisabled() {
@@ -221,7 +221,7 @@ func (s *AuthTestSuite) TestParse_TokenDisabled() {
 
 	payload, err := s.auth.Parse(token)
 	s.Nil(payload)
-	s.EqualError(err, "token is disabled")
+	s.EqualError(err, errors.ErrAuthTokenDisabled.Error())
 }
 
 func (s *AuthTestSuite) TestParse_TokenInvalid() {
@@ -260,7 +260,7 @@ func (s *AuthTestSuite) TestParse_TokenExpired() {
 		ExpireAt: jwt.NewNumericDate(expireAt).Local(),
 		IssuedAt: jwt.NewNumericDate(issuedAt).Local(),
 	}, payload)
-	s.ErrorIs(err, ErrorTokenExpired)
+	s.ErrorIs(err, errors.ErrAuthTokenExpired)
 
 	carbon.UnsetTestNow()
 
@@ -271,7 +271,7 @@ func (s *AuthTestSuite) TestParse_InvalidCache() {
 	auth := NewAuth(testUserGuard, nil, s.mockConfig, s.mockContext, s.mockOrm)
 	payload, err := auth.Parse("1")
 	s.Nil(payload)
-	s.EqualError(err, "cache support is required")
+	s.EqualError(err, errors.ErrCacheSupportRequired.SetModule(errors.ModuleAuth).Error())
 }
 
 func (s *AuthTestSuite) TestParse_Success() {
@@ -326,15 +326,15 @@ func (s *AuthTestSuite) TestParse_ExpiredAndInvalid() {
 	s.mockCache.On("GetBool", "jwt:disabled:"+token, false).Return(false).Once()
 
 	_, err := s.auth.Parse(token)
-	s.ErrorIs(err, ErrorInvalidToken)
+	s.ErrorIs(err, errors.ErrAuthInvalidToken)
 
 	s.mockConfig.AssertExpectations(s.T())
 }
 
 func (s *AuthTestSuite) TestUser_NoParse() {
 	var user User
 	err := s.auth.User(user)
-	s.EqualError(err, "parse token first")
+	s.EqualError(err, errors.ErrAuthParseTokenFirst.Error())
 
 	s.mockConfig.AssertExpectations(s.T())
 }
@@ -380,7 +380,7 @@ func (s *AuthTestSuite) TestID_TokenExpired() {
 
 	// Parse the token
 	_, err = s.auth.Parse(token)
-	s.ErrorIs(err, ErrorTokenExpired)
+	s.ErrorIs(err, errors.ErrAuthTokenExpired)
 
 	// Now, call the ID method and expect it to return an empty value
 	id, _ := s.auth.Id()
@@ -397,7 +397,7 @@ func (s *AuthTestSuite) TestID_TokenInvalid() {
 	s.mockCache.On("GetBool", "jwt:disabled:"+token, false).Return(false).Once()
 
 	_, err := s.auth.Parse(token)
-	s.ErrorIs(err, ErrorInvalidToken)
+	s.ErrorIs(err, errors.ErrAuthInvalidToken)
 
 	id, _ := s.auth.Id()
 	s.Empty(id)
@@ -441,11 +441,11 @@ func (s *AuthTestSuite) TestUser_Expired() {
 
 	payload, err := s.auth.Parse(token)
 	s.NotNil(payload)
-	s.ErrorIs(err, ErrorTokenExpired)
+	s.ErrorIs(err, errors.ErrAuthTokenExpired)
 
 	var user User
 	err = s.auth.User(&user)
-	s.EqualError(err, "token expired")
+	s.EqualError(err, errors.ErrAuthTokenExpired.Error())
 
 	s.mockConfig.On("GetInt", "jwt.refresh_ttl").Return(2).Once()
 
@@ -478,19 +478,19 @@ func (s *AuthTestSuite) TestUser_RefreshExpired() {
 
 	payload, err := s.auth.Parse(token)
 	s.NotNil(payload)
-	s.ErrorIs(err, ErrorTokenExpired)
+	s.ErrorIs(err, errors.ErrAuthTokenExpired)
 
 	var user User
 	err = s.auth.User(&user)
-	s.EqualError(err, "token expired")
+	s.EqualError(err, errors.ErrAuthTokenExpired.Error())
 
 	s.mockConfig.On("GetInt", "jwt.refresh_ttl").Return(1).Once()
 
 	carbon.SetTestNow(carbon.Now().AddMinutes(2))
 
 	token, err = s.auth.Refresh()
 	s.Empty(token)
-	s.EqualError(err, "refresh time exceeded")
+	s.EqualError(err, errors.ErrAuthRefreshTimeExceeded.Error())
 
 	carbon.UnsetTestNow()
 
@@ -577,7 +577,7 @@ func (s *AuthTestSuite) TestUser_Success_MultipleParse() {
 func (s *AuthTestSuite) TestRefresh_NotParse() {
 	token, err := s.auth.Refresh()
 	s.Empty(token)
-	s.EqualError(err, "parse token first")
+	s.EqualError(err, errors.ErrAuthParseTokenFirst.Error())
 
 	s.mockConfig.AssertExpectations(s.T())
 }
@@ -602,7 +602,7 @@ func (s *AuthTestSuite) TestRefresh_RefreshTimeExceeded() {
 
 	token, err = s.auth.Refresh()
 	s.Empty(token)
-	s.EqualError(err, "refresh time exceeded")
+	s.EqualError(err, errors.ErrAuthRefreshTimeExceeded.Error())
 
 	carbon.UnsetTestNow()
 
@@ -653,7 +653,7 @@ func (s *AuthTestSuite) TestLogout_CacheUnsupported() {
 	token, err := s.auth.LoginUsingID(1)
 	s.NotEmpty(token)
 	s.Nil(err)
-	s.EqualError(s.auth.Logout(), "cache support is required")
+	s.EqualError(s.auth.Logout(), errors.ErrCacheSupportRequired.SetModule(errors.ModuleAuth).Error())
 
 	s.mockConfig.AssertExpectations(s.T())
 }
@@ -740,7 +740,7 @@ func (s *AuthTestSuite) TestLogout_Error_TTL_Is_0() {
 
 	s.mockCache.On("Forever", testifymock.Anything, true).Return(false).Once()
 
-	s.EqualError(s.auth.Logout(), "cache forever failed")
+	s.EqualError(s.auth.Logout(), errors.ErrCacheForeverFailed.SetModule(errors.ModuleAuth).Error())
 
 	s.mockConfig.AssertExpectations(s.T())
 }

auth/service_provider.go

@@ -8,6 +8,7 @@ import (
 	contractconsole "github.com/goravel/framework/contracts/console"
 	"github.com/goravel/framework/contracts/foundation"
 	"github.com/goravel/framework/contracts/http"
+	"github.com/goravel/framework/errors"
 )
 
 const BindingAuth = "goravel.auth"
@@ -19,8 +20,21 @@ type ServiceProvider struct {
 func (database *ServiceProvider) Register(app foundation.Application) {
 	app.BindWith(BindingAuth, func(app foundation.Application, parameters map[string]any) (any, error) {
 		config := app.MakeConfig()
+		if config == nil {
+			return nil, errors.ErrConfigFacadeNotSet.SetModule(errors.ModuleAuth)
+		}
+		cacheFacade := app.MakeCache()
+		if cacheFacade == nil {
+			return nil, errors.ErrCacheFacadeNotSet.SetModule(errors.ModuleAuth)
+		}
+
+		ormFacade := app.MakeOrm()
+		if ormFacade == nil {
+			return nil, errors.ErrOrmFacadeNotSet.SetModule(errors.ModuleAuth)
+		}
+
 		return NewAuth(config.GetString("auth.defaults.guard"),
-			app.MakeCache(), config, parameters["ctx"].(http.Context), app.MakeOrm()), nil
+			cacheFacade, config, parameters["ctx"].(http.Context), ormFacade), nil
 	})
 	app.Singleton(BindingGate, func(app foundation.Application) (any, error) {
 		return access.NewGate(context.Background()), nil