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

auth/service_provider.go

@@ -32,8 +32,10 @@
 }
 
 func (database *ServiceProvider) registerCommands(app foundation.Application) {
-	app.MakeArtisan().Register([]contractconsole.Command{
-		console.NewJwtSecretCommand(app.MakeConfig()),
-		console.NewPolicyMakeCommand(),
-	})
+	if artisanFacade := app.MakeArtisan(); artisanFacade != nil {
+		artisanFacade.Register([]contractconsole.Command{
+			console.NewJwtSecretCommand(app.MakeConfig()),
+			console.NewPolicyMakeCommand(),
+		})
+	}
 }

cache/service_provider.go

@@ -26,7 +26,9 @@
 }
 
 func (database *ServiceProvider) registerCommands(app foundation.Application) {
-	app.MakeArtisan().Register([]contractsconsole.Command{
-		console.NewClearCommand(app.MakeCache()),
-	})
+	if artisanFacade := app.MakeArtisan(); artisanFacade != nil {
+		artisanFacade.Register([]contractsconsole.Command{
+			console.NewClearCommand(app.MakeCache()),
+		})
+	}
 }

console/application.go

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

console/application_test.go

@@ -40,6 +40,8 @@ func TestFlagsToCliFlags(t *testing.T) {
 	// Convert command flags to CLI flags
 	cliFlags := flagsToCliFlags(flags)
 
+	assert.NotEmpty(t, cliFlags, "cliFlags should not be empty")
+
 	// Assert that the number of CLI flags matches the number of command flags
 	assert.Equal(t, len(cliFlags), len(flags))
 

console/console/key_generate_command.go

@@ -1,6 +1,7 @@
 package console
 
 import (
+	"errors"
 	"os"
 	"strings"
 
@@ -41,6 +42,10 @@
 
 // Handle Execute the console command.
 func (receiver *KeyGenerateCommand) Handle(ctx console.Context) error {
+	if receiver.config == nil {
+		return errors.New("config facade not set")
+	}
+
 	if receiver.config.GetString("app.env") == "production" {
 		color.Yellow().Println("**************************************")
 		color.Yellow().Println("*     Application In Production!     *")

console/progress_bar.go

@@ -19,10 +19,16 @@
 }
 
 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

@@ -25,12 +25,13 @@
 }
 
 func (receiver *ServiceProvider) registerCommands(app foundation.Application) {
-	artisan := app.MakeArtisan()
-	config := app.MakeConfig()
-	artisan.Register([]consolecontract.Command{
-		console.NewListCommand(artisan),
-		console.NewKeyGenerateCommand(config),
-		console.NewMakeCommand(),
-		console.NewBuildCommand(config),
-	})
+	if artisanFacade := app.MakeArtisan(); artisanFacade != nil {
+		config := app.MakeConfig()
+		artisanFacade.Register([]consolecontract.Command{
+			console.NewListCommand(artisanFacade),
+			console.NewKeyGenerateCommand(config),
+			console.NewMakeCommand(),
+			console.NewBuildCommand(config),
+		})
+	}
 }

crypt/aes.go

@@ -6,6 +6,7 @@
 	"crypto/rand"
 	"encoding/base64"
 	"errors"
+	"fmt"
 	"io"
 
 	"github.com/goravel/framework/contracts/config"
@@ -20,24 +21,35 @@
 }
 
 // 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) {
+	if config == nil {
+		return nil, ErrConfigNotSet
+	}
+
+	if json == nil {
+		return nil, ErrJsonParserNotSet
+	}
+
 	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,7 @@
 
 func (crypt *ServiceProvider) Register(app foundation.Application) {
 	app.Singleton(Binding, func(app foundation.Application) (any, error) {
-		return NewAES(app.MakeConfig(), app.GetJson()), nil
+		return NewAES(app.MakeConfig(), app.GetJson())
 	})
 }
 

database/gorm/gorm.go

@@ -52,8 +52,10 @@
 		return nil, fmt.Errorf("init gorm dialector error: %v", err)
 	}
 
-	if err := r.init(writeDialectors[0]); err != nil {
-		return nil, err
+	if len(writeDialectors) > 0 {
+		if err := r.init(writeDialectors[0]); err != nil {
+			return nil, err
+		}
 	}
 
 	if err := r.configurePool(); err != nil {

database/service_provider.go

@@ -44,21 +44,22 @@
 }
 
 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,8 +22,10 @@
 }
 
 func (receiver *ServiceProvider) registerCommands(app foundation.Application) {
-	app.MakeArtisan().Register([]console.Command{
-		&eventConsole.EventMakeCommand{},
-		&eventConsole.ListenerMakeCommand{},
-	})
+	if artisanFacade := app.MakeArtisan(); artisanFacade != nil {
+		artisanFacade.Register([]console.Command{
+			&eventConsole.EventMakeCommand{},
+			&eventConsole.ListenerMakeCommand{},
+		})
+	}
 }

facades/app.go

@@ -6,5 +6,10 @@ import (
 )
 
 func App() foundationcontract.Application {
-	return foundation.App
+	app := foundation.App
+	if app == nil {
+		panic(ErrApplicationNotSet)
+	}
+
+	return 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")
+)