feat: [#491] Fix the errors thrown by Lint/nilaway CI

auth/service_provider.go

@@ -32,7 +32,7 @@ func (database *ServiceProvider) Boot(app foundation.Application) {
 }
 
 func (database *ServiceProvider) registerCommands(app foundation.Application) {
-	app.MakeArtisan().Register([]contractconsole.Command{
+	app.Commands([]contractconsole.Command{
 		console.NewJwtSecretCommand(app.MakeConfig()),
 		console.NewPolicyMakeCommand(),
 	})

cache/service_provider.go

@@ -26,7 +26,7 @@ func (database *ServiceProvider) Boot(app foundation.Application) {
 }
 
 func (database *ServiceProvider) registerCommands(app foundation.Application) {
-	app.MakeArtisan().Register([]contractsconsole.Command{
+	app.Commands([]contractsconsole.Command{
 		console.NewClearCommand(app.MakeCache()),
 	})
 }

console/application.go

@@ -47,19 +47,31 @@ func (c *Application) Register(commands []console.Command) {
 
 // Call Run an Artisan console command by name.
 func (c *Application) Call(command string) {
+	if len(os.Args) == 0 {
+		return
+	}
+
 	commands := []string{os.Args[0]}
+
 	if c.isArtisan {
 		commands = append(commands, "artisan")
 	}
+
 	c.Run(append(commands, strings.Split(command, " ")...), false)
 }
 
 // CallAndExit Run an Artisan console command by name and exit.
 func (c *Application) CallAndExit(command string) {
+	if len(os.Args) == 0 {
+		return
+	}
+
 	commands := []string{os.Args[0]}
+
 	if c.isArtisan {
 		commands = append(commands, "artisan")
 	}
+
 	c.Run(append(commands, strings.Split(command, " ")...), true)
 }
 

console/progress_bar.go

@@ -19,10 +19,16 @@ func NewProgressBar(total int) *ProgressBar {
 }
 
 func (r *ProgressBar) Advance(step ...int) {
+	var instance *pterm.ProgressbarPrinter
+
 	if len(step) > 0 {
-		r.instance = r.instance.Add(step[0])
+		instance = r.instance.Add(step[0])
 	} else {
-		r.instance = r.instance.Increment()
+		instance = r.instance.Increment()
+	}
+
+	if instance != nil {
+		r.instance = instance
 	}
 }
 

console/service_provider.go

@@ -4,6 +4,7 @@ import (
 	"github.com/goravel/framework/console/console"
 	consolecontract "github.com/goravel/framework/contracts/console"
 	"github.com/goravel/framework/contracts/foundation"
+	"github.com/goravel/framework/support/color"
 )
 
 const Binding = "goravel.console"
@@ -25,12 +26,22 @@ func (receiver *ServiceProvider) Boot(app foundation.Application) {
 }
 
 func (receiver *ServiceProvider) registerCommands(app foundation.Application) {
-	artisan := app.MakeArtisan()
-	config := app.MakeConfig()
-	artisan.Register([]consolecontract.Command{
-		console.NewListCommand(artisan),
-		console.NewKeyGenerateCommand(config),
+	artisanFacade := app.MakeArtisan()
+	if artisanFacade == nil {
+		color.Yellow().Println("Warning: Artisan Facade is not initialized. Skipping command registration.")
+		return
+	}
+
+	configFacade := app.MakeConfig()
+	if configFacade == nil {
+		color.Yellow().Println("Warning: Config Facade is not initialized. Skipping certain command registrations.")
+		return
+	}
+
+	artisanFacade.Register([]consolecontract.Command{
+		console.NewListCommand(artisanFacade),
+		console.NewKeyGenerateCommand(configFacade),
 		console.NewMakeCommand(),
-		console.NewBuildCommand(config),
+		console.NewBuildCommand(configFacade),
 	})
 }

crypt/aes.go

@@ -6,6 +6,7 @@ import (
 	"crypto/rand"
 	"encoding/base64"
 	"errors"
+	"fmt"
 	"io"
 
 	"github.com/goravel/framework/contracts/config"
@@ -20,24 +21,27 @@ type AES struct {
 }
 
 // NewAES returns a new AES hasher.
-func NewAES(config config.Config, json foundation.Json) *AES {
+func NewAES(config config.Config, json foundation.Json) (*AES, error) {
 	key := config.GetString("app.key")
 
 	// Don't use AES in artisan when the key is empty.
 	if support.Env == support.EnvArtisan && len(key) == 0 {
-		return nil
+		return nil, ErrAppKeyNotSetInArtisan
 	}
 
+	keyLength := len(key)
 	// check key length before using it
-	if len(key) != 16 && len(key) != 24 && len(key) != 32 {
-		color.Red().Println("[Crypt] Empty or invalid APP_KEY, please reset it.\nExample command:\ngo run . artisan key:generate")
-		return nil
+	if keyLength != 16 && keyLength != 24 && keyLength != 32 {
+		color.Red().Printf("[Crypt] Invalid APP_KEY length. Expected 16, 24, or 32 bytes, but got %d bytes.\n", len(key))
+		color.Red().Println("Please reset it using the following command:\ngo run . artisan key:generate")
+		return nil, fmt.Errorf("%w: %d bytes", ErrInvalidAppKeyLength, keyLength)
 	}
+
 	keyBytes := []byte(key)
 	return &AES{
 		key:  keyBytes,
 		json: json,
-	}
+	}, nil
 }
 
 // EncryptString encrypts the given string, and returns the iv and ciphertext as base64 encoded strings.

crypt/aes_test.go

@@ -3,6 +3,7 @@ package crypt
 import (
 	"testing"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/suite"
 
 	"github.com/goravel/framework/foundation/json"
@@ -17,8 +18,12 @@ type AesTestSuite struct {
 func TestAesTestSuite(t *testing.T) {
 	mockConfig := &configmock.Config{}
 	mockConfig.On("GetString", "app.key").Return("11111111111111111111111111111111").Once()
+	aes, err := NewAES(mockConfig, json.NewJson())
+
+	assert.NoError(t, err)
+
 	suite.Run(t, &AesTestSuite{
-		aes: NewAES(mockConfig, json.NewJson()),
+		aes: aes,
 	})
 	mockConfig.AssertExpectations(t)
 }
@@ -61,7 +66,11 @@ func (s *AesTestSuite) TestDecryptString() {
 func Benchmark_EncryptString(b *testing.B) {
 	mockConfig := &configmock.Config{}
 	mockConfig.On("GetString", "app.key").Return("11111111111111111111111111111111").Once()
-	aes := NewAES(mockConfig, json.NewJson())
+	aes, err := NewAES(mockConfig, json.NewJson())
+	if err != nil {
+		b.Fatal(err)
+	}
+
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
@@ -75,7 +84,11 @@ func Benchmark_EncryptString(b *testing.B) {
 func Benchmark_DecryptString(b *testing.B) {
 	mockConfig := &configmock.Config{}
 	mockConfig.On("GetString", "app.key").Return("11111111111111111111111111111111").Once()
-	aes := NewAES(mockConfig, json.NewJson())
+	aes, err := NewAES(mockConfig, json.NewJson())
+	if err != nil {
+		b.Fatal(err)
+	}
+
 	payload, err := aes.EncryptString("Goravel")
 	if err != nil {
 		b.Error(err)

crypt/errors.go

@@ -0,0 +1,12 @@
+package crypt
+
+import (
+	"errors"
+)
+
+var (
+	ErrConfigNotSet          = errors.New("config must not be nil")
+	ErrJsonParserNotSet      = errors.New("JSON parser must not be nil")
+	ErrAppKeyNotSetInArtisan = errors.New("APP_KEY is required in artisan environment")
+	ErrInvalidAppKeyLength   = errors.New("invalid APP_KEY length")
+)

crypt/service_provider.go

@@ -11,7 +11,17 @@ type ServiceProvider struct {
 
 func (crypt *ServiceProvider) Register(app foundation.Application) {
 	app.Singleton(Binding, func(app foundation.Application) (any, error) {
-		return NewAES(app.MakeConfig(), app.GetJson()), nil
+		c := app.MakeConfig()
+		if c == nil {
+			return nil, ErrConfigNotSet
+		}
+
+		j := app.GetJson()
+		if j == nil {
+			return nil, ErrJsonParserNotSet
+		}
+
+		return NewAES(c, j)
 	})
 }
 

database/gorm/dialector_test.go

@@ -46,11 +46,12 @@ func (s *DialectorTestSuite) TestMysql() {
 	s.mockConfig.On("GetString", "database.connections.mysql.loc").
 		Return("Local").Once()
 	dialectors, err := dialector.Make([]databasecontract.Config{s.config})
+	s.Nil(err)
+	s.NotEmpty(dialectors)
 	s.Equal(mysql.New(mysql.Config{
 		DSN: fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=%s&parseTime=%t&loc=%s&multiStatements=true",
 			s.config.Username, s.config.Password, s.config.Host, s.config.Port, s.config.Database, "utf8mb4", true, "Local"),
 	}), dialectors[0])
-	s.Nil(err)
 }
 
 func (s *DialectorTestSuite) TestPostgres() {
@@ -62,20 +63,22 @@ func (s *DialectorTestSuite) TestPostgres() {
 	s.mockConfig.On("GetString", "database.connections.postgres.timezone").
 		Return("UTC").Once()
 	dialectors, err := dialector.Make([]databasecontract.Config{s.config})
+	s.Nil(err)
+	s.NotEmpty(dialectors)
 	s.Equal(postgres.New(postgres.Config{
 		DSN: fmt.Sprintf("postgres://%s:%s@%s:%d/%s?sslmode=%s&timezone=%s",
 			s.config.Username, s.config.Password, s.config.Host, s.config.Port, s.config.Database, "disable", "UTC"),
 	}), dialectors[0])
-	s.Nil(err)
 }
 
 func (s *DialectorTestSuite) TestSqlite() {
 	dialector := NewDialectorImpl(s.mockConfig, orm.DriverSqlite.String())
 	s.mockConfig.On("GetString", "database.connections.sqlite.driver").
 		Return(orm.DriverSqlite.String()).Once()
 	dialectors, err := dialector.Make([]databasecontract.Config{s.config})
-	s.Equal(sqlite.Open(fmt.Sprintf("%s?multi_stmts=true", s.config.Database)), dialectors[0])
 	s.Nil(err)
+	s.NotEmpty(dialectors)
+	s.Equal(sqlite.Open(fmt.Sprintf("%s?multi_stmts=true", s.config.Database)), dialectors[0])
 }
 
 func (s *DialectorTestSuite) TestSqlserver() {
@@ -85,9 +88,10 @@ func (s *DialectorTestSuite) TestSqlserver() {
 	s.mockConfig.On("GetString", "database.connections.sqlserver.charset").
 		Return("utf8mb4").Once()
 	dialectors, err := dialector.Make([]databasecontract.Config{s.config})
+	s.Nil(err)
+	s.NotEmpty(dialectors)
 	s.Equal(sqlserver.New(sqlserver.Config{
 		DSN: fmt.Sprintf("sqlserver://%s:%s@%s:%d?database=%s&charset=%s&MultipleActiveResultSets=true",
 			s.config.Username, s.config.Password, s.config.Host, s.config.Port, s.config.Database, "utf8mb4"),
 	}), dialectors[0])
-	s.Nil(err)
 }

database/gorm/gorm.go

@@ -52,6 +52,10 @@ func (r *GormImpl) Make() (*gormio.DB, error) {
 		return nil, fmt.Errorf("init gorm dialector error: %v", err)
 	}
 
+	if len(writeDialectors) == 0 {
+		return nil, errors.New("no write dialectors found")
+	}
+
 	if err := r.init(writeDialectors[0]); err != nil {
 		return nil, err
 	}

database/service_provider.go

@@ -51,21 +51,22 @@ func (database *ServiceProvider) Boot(app foundation.Application) {
 }
 
 func (database *ServiceProvider) registerCommands(app foundation.Application) {
-	config := app.MakeConfig()
-	seeder := app.MakeSeeder()
-	artisan := app.MakeArtisan()
-	app.MakeArtisan().Register([]consolecontract.Command{
-		console.NewMigrateMakeCommand(config),
-		console.NewMigrateCommand(config),
-		console.NewMigrateRollbackCommand(config),
-		console.NewMigrateResetCommand(config),
-		console.NewMigrateRefreshCommand(config, artisan),
-		console.NewMigrateFreshCommand(config, artisan),
-		console.NewMigrateStatusCommand(config),
-		console.NewModelMakeCommand(),
-		console.NewObserverMakeCommand(),
-		console.NewSeedCommand(config, seeder),
-		console.NewSeederMakeCommand(),
-		console.NewFactoryMakeCommand(),
-	})
+	if artisanFacade := app.MakeArtisan(); artisanFacade != nil {
+		config := app.MakeConfig()
+		seeder := app.MakeSeeder()
+		artisanFacade.Register([]consolecontract.Command{
+			console.NewMigrateMakeCommand(config),
+			console.NewMigrateCommand(config),
+			console.NewMigrateRollbackCommand(config),
+			console.NewMigrateResetCommand(config),
+			console.NewMigrateRefreshCommand(config, artisanFacade),
+			console.NewMigrateFreshCommand(config, artisanFacade),
+			console.NewMigrateStatusCommand(config),
+			console.NewModelMakeCommand(),
+			console.NewObserverMakeCommand(),
+			console.NewSeedCommand(config, seeder),
+			console.NewSeederMakeCommand(),
+			console.NewFactoryMakeCommand(),
+		})
+	}
 }

event/service_provider.go

@@ -22,7 +22,7 @@ func (receiver *ServiceProvider) Boot(app foundation.Application) {
 }
 
 func (receiver *ServiceProvider) registerCommands(app foundation.Application) {
-	app.MakeArtisan().Register([]console.Command{
+	app.Commands([]console.Command{
 		&eventConsole.EventMakeCommand{},
 		&eventConsole.ListenerMakeCommand{},
 	})

facades/app.go

@@ -6,5 +6,9 @@ import (
 )
 
 func App() foundationcontract.Application {
-	return foundation.App
+	if foundation.App == nil {
+		panic(ErrApplicationNotSet)
+	} else {
+		return foundation.App
+	}
 }

facades/errors.go

@@ -0,0 +1,7 @@
+package facades
+
+import "errors"
+
+var (
+	ErrApplicationNotSet = errors.New("application instance not initialized")
+)

filesystem/errors.go

@@ -0,0 +1,7 @@
+package filesystem
+
+import "errors"
+
+var (
+	ErrStorageFacadeNotSet = errors.New("storage facade not set")
+)