feat: [#880] make commands accept multiple names

console/console/make_command.go

@@ -52,10 +52,19 @@ func (r *MakeCommand) Extend() command.Extend {
 
 // Handle Execute the console command.
 func (r *MakeCommand) Handle(ctx console.Context) error {
-	make, err := supportconsole.NewMake(ctx, "command", ctx.Argument(0), support.Config.Paths.Commands)
+	for _, name := range supportconsole.MakeNames(ctx) {
+		if err := r.makeOne(ctx, name); err != nil {
+			ctx.Error(err.Error())
+		}
+	}
+
+	return nil
+}
+
+func (r *MakeCommand) makeOne(ctx console.Context, name string) error {
+	make, err := supportconsole.NewMake(ctx, "command", name, support.Config.Paths.Commands)
 	if err != nil {
-		ctx.Error(err.Error())
-		return nil
+		return err
 	}
 
 	if err := file.PutContent(make.GetFilePath(), r.populateStub(r.getStub(), make.GetPackageName(), make.GetStructName(), make.GetSignature())); err != nil {
@@ -71,8 +80,7 @@ func (r *MakeCommand) Handle(ctx console.Context) error {
 	}
 
 	if err != nil {
-		ctx.Error(errors.ConsoleCommandRegisterFailed.Args(make.GetSignature(), err).Error())
-		return nil
+		return errors.ConsoleCommandRegisterFailed.Args(make.GetSignature(), err)
 	}
 
 	ctx.Success("Console command registered successfully")

console/console/make_command_test.go

@@ -46,7 +46,7 @@ func TestMakeCommand(t *testing.T) {
 		assert.NoError(t, file.PutContent(kernelPath, kernel))
 
 		mockContext := mocksconsole.NewContext(t)
-		mockContext.EXPECT().Argument(0).Return("").Once()
+		mockContext.EXPECT().Arguments().Return(nil).Once()
 		mockContext.EXPECT().Ask("Enter the command name", mock.Anything).Return("", errors.New("the command name cannot be empty")).Once()
 		mockContext.EXPECT().Error("the command name cannot be empty").Once()
 		assert.Nil(t, makeCommand.Handle(mockContext))
@@ -69,7 +69,7 @@ func (kernel Kernel) Schedule() []schedule.Event {
 `))
 
 		mockContext := mocksconsole.NewContext(t)
-		mockContext.EXPECT().Argument(0).Return("CleanCache").Once()
+		mockContext.EXPECT().Arguments().Return([]string{"CleanCache"}).Once()
 		mockContext.EXPECT().OptionBool("force").Return(false).Once()
 		mockContext.EXPECT().Success("Console command created successfully").Once()
 		mockContext.EXPECT().Error(mock.MatchedBy(func(msg string) bool {
@@ -84,7 +84,7 @@ func (kernel Kernel) Schedule() []schedule.Event {
 
 	t.Run("command already exists", func(t *testing.T) {
 		mockContext := mocksconsole.NewContext(t)
-		mockContext.EXPECT().Argument(0).Return("CleanCache").Once()
+		mockContext.EXPECT().Arguments().Return([]string{"CleanCache"}).Once()
 		mockContext.EXPECT().OptionBool("force").Return(false).Once()
 		mockContext.EXPECT().Error("the command already exists. Use the --force or -f flag to overwrite").Once()
 		assert.Nil(t, makeCommand.Handle(mockContext))
@@ -94,7 +94,7 @@ func (kernel Kernel) Schedule() []schedule.Event {
 		assert.NoError(t, file.PutContent(kernelPath, kernel))
 
 		mockContext := mocksconsole.NewContext(t)
-		mockContext.EXPECT().Argument(0).Return("Goravel/CleanCache").Once()
+		mockContext.EXPECT().Arguments().Return([]string{"Goravel/CleanCache"}).Once()
 		mockContext.EXPECT().OptionBool("force").Return(false).Once()
 		mockContext.EXPECT().Success("Console command created successfully").Once()
 		mockContext.EXPECT().Success("Console command registered successfully").Once()
@@ -111,6 +111,34 @@ func (kernel Kernel) Schedule() []schedule.Event {
 	})
 }
 
+func TestMakeCommand_MultipleNames(t *testing.T) {
+	defer func() {
+		assert.Nil(t, file.Remove("app"))
+	}()
+
+	kernelPath := filepath.Join("app", "console", "kernel.go")
+	assert.NoError(t, file.PutContent(kernelPath, kernel))
+
+	makeCommand := &MakeCommand{}
+	mockContext := mocksconsole.NewContext(t)
+
+	mockContext.EXPECT().Arguments().Return([]string{"Goravel/CleanCache", "Bar/SyncUsers"}).Once()
+	mockContext.EXPECT().OptionBool("force").Return(false).Times(2)
+	mockContext.EXPECT().Success("Console command created successfully").Times(2)
+	mockContext.EXPECT().Success("Console command registered successfully").Times(2)
+
+	assert.Nil(t, makeCommand.Handle(mockContext))
+
+	cleanCachePath := filepath.Join("app", "console", "commands", "Goravel", "clean_cache.go")
+	syncUsersPath := filepath.Join("app", "console", "commands", "Bar", "sync_users.go")
+	assert.True(t, file.Exists(cleanCachePath))
+	assert.True(t, file.Exists(syncUsersPath))
+	assert.True(t, file.Contain(cleanCachePath, "app:goravel-clean-cache"))
+	assert.True(t, file.Contain(syncUsersPath, "app:bar-sync-users"))
+	assert.True(t, file.Contain(kernelPath, "&Goravel.CleanCache{}"))
+	assert.True(t, file.Contain(kernelPath, "&Bar.SyncUsers{}"))
+}
+
 func TestMakeCommand_AddCommandToBootstrapSetup(t *testing.T) {
 	makeCommand := &MakeCommand{}
 	bootstrapPath := filepath.Join("bootstrap", "app.go")
@@ -137,7 +165,7 @@ func Boot() contractsfoundation.Application {
 
 	// Create mock context
 	mockContext := mocksconsole.NewContext(t)
-	mockContext.EXPECT().Argument(0).Return("CleanCache").Once()
+	mockContext.EXPECT().Arguments().Return([]string{"CleanCache"}).Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Success("Console command created successfully").Once()
 	mockContext.EXPECT().Success("Console command registered successfully").Once()

http/console/controller_make_command.go

@@ -44,10 +44,19 @@ func (r *ControllerMakeCommand) Extend() command.Extend {
 
 // Handle Execute the console command.
 func (r *ControllerMakeCommand) Handle(ctx console.Context) error {
-	m, err := supportconsole.NewMake(ctx, "controller", ctx.Argument(0), support.Config.Paths.Controllers)
+	for _, name := range supportconsole.MakeNames(ctx) {
+		if err := r.makeOne(ctx, name); err != nil {
+			ctx.Error(err.Error())
+		}
+	}
+
+	return nil
+}
+
+func (r *ControllerMakeCommand) makeOne(ctx console.Context, name string) error {
+	m, err := supportconsole.NewMake(ctx, "controller", name, support.Config.Paths.Controllers)
 	if err != nil {
-		ctx.Error(err.Error())
-		return nil
+		return err
 	}
 
 	stub := r.getStub()
@@ -56,8 +65,7 @@ func (r *ControllerMakeCommand) Handle(ctx console.Context) error {
 	}
 
 	if err := file.PutContent(m.GetFilePath(), r.populateStub(stub, m.GetPackageName(), m.GetStructName())); err != nil {
-		ctx.Error(err.Error())
-		return nil
+		return err
 	}
 
 	ctx.Success("Controller created successfully")

http/console/controller_make_command_test.go

@@ -14,24 +14,24 @@ import (
 func TestControllerMakeCommand(t *testing.T) {
 	controllerMakeCommand := &ControllerMakeCommand{}
 	mockContext := mocksconsole.NewContext(t)
-	mockContext.EXPECT().Argument(0).Return("").Once()
+	mockContext.EXPECT().Arguments().Return(nil).Once()
 	mockContext.EXPECT().Ask("Enter the controller name", mock.Anything).Return("", errors.New("the controller name cannot be empty")).Once()
 	mockContext.EXPECT().Error("the controller name cannot be empty").Once()
 	assert.Nil(t, controllerMakeCommand.Handle(mockContext))
 
-	mockContext.EXPECT().Argument(0).Return("UsersController").Once()
+	mockContext.EXPECT().Arguments().Return([]string{"UsersController"}).Once()
 	mockContext.EXPECT().OptionBool("resource").Return(false).Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Success("Controller created successfully").Once()
 	assert.Nil(t, controllerMakeCommand.Handle(mockContext))
 	assert.True(t, file.Exists("app/http/controllers/users_controller.go"))
 
-	mockContext.EXPECT().Argument(0).Return("UsersController").Once()
+	mockContext.EXPECT().Arguments().Return([]string{"UsersController"}).Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Error("the controller already exists. Use the --force or -f flag to overwrite").Once()
 	assert.Nil(t, controllerMakeCommand.Handle(mockContext))
 
-	mockContext.EXPECT().Argument(0).Return("User/AuthController").Once()
+	mockContext.EXPECT().Arguments().Return([]string{"User/AuthController"}).Once()
 	mockContext.EXPECT().OptionBool("resource").Return(false).Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Success("Controller created successfully").Once()
@@ -43,10 +43,57 @@ func TestControllerMakeCommand(t *testing.T) {
 	assert.Nil(t, file.Remove("app"))
 }
 
+func TestControllerMakeCommand_MultipleNames(t *testing.T) {
+	controllerMakeCommand := &ControllerMakeCommand{}
+	mockContext := mocksconsole.NewContext(t)
+
+	mockContext.EXPECT().Arguments().Return([]string{"UserController", "OrderController"}).Once()
+	mockContext.EXPECT().OptionBool("resource").Return(false).Times(2)
+	mockContext.EXPECT().OptionBool("force").Return(false).Times(2)
+	mockContext.EXPECT().Success("Controller created successfully").Times(2)
+
+	assert.Nil(t, controllerMakeCommand.Handle(mockContext))
+
+	assert.True(t, file.Exists("app/http/controllers/user_controller.go"))
+	assert.True(t, file.Exists("app/http/controllers/order_controller.go"))
+	assert.Nil(t, file.Remove("app"))
+}
+
+// TestControllerMakeCommand_MultipleNamesPartialFailure verifies that when
+// creating several controllers at once, a failure for one name (e.g. the file
+// already exists) does not stop the remaining names from being processed,
+// mirroring the behavior of tools like `mkdir`.
+func TestControllerMakeCommand_MultipleNamesPartialFailure(t *testing.T) {
+	controllerMakeCommand := &ControllerMakeCommand{}
+	mockContext := mocksconsole.NewContext(t)
+
+	// First create a controller so it already exists, then try to create it again
+	// alongside a new one.
+	mockContext.EXPECT().Arguments().Return([]string{"UserController"}).Once()
+	mockContext.EXPECT().OptionBool("resource").Return(false).Once()
+	mockContext.EXPECT().OptionBool("force").Return(false).Once()
+	mockContext.EXPECT().Success("Controller created successfully").Once()
+	assert.Nil(t, controllerMakeCommand.Handle(mockContext))
+
+	mockContext.EXPECT().Arguments().Return([]string{"UserController", "OrderController"}).Once()
+	// UserController: NewMake checks force, then fails because the file exists,
+	// so it never reaches the resource flag. OrderController: checks force, then
+	// resource, then succeeds.
+	mockContext.EXPECT().OptionBool("force").Return(false).Times(2)
+	mockContext.EXPECT().OptionBool("resource").Return(false).Once()
+	mockContext.EXPECT().Error("the controller already exists. Use the --force or -f flag to overwrite").Once()
+	mockContext.EXPECT().Success("Controller created successfully").Once()
+	assert.Nil(t, controllerMakeCommand.Handle(mockContext))
+
+	assert.True(t, file.Exists("app/http/controllers/user_controller.go"))
+	assert.True(t, file.Exists("app/http/controllers/order_controller.go"))
+	assert.Nil(t, file.Remove("app"))
+}
+
 func TestResourceControllerMakeCommand(t *testing.T) {
 	controllerMakeCommand := &ControllerMakeCommand{}
 	mockContext := mocksconsole.NewContext(t)
-	mockContext.EXPECT().Argument(0).Return("User/AuthController").Once()
+	mockContext.EXPECT().Arguments().Return([]string{"User/AuthController"}).Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().OptionBool("resource").Return(true).Once()
 	mockContext.EXPECT().Success("Controller created successfully").Once()

http/console/middleware_make_command.go

@@ -39,15 +39,23 @@ func (r *MiddlewareMakeCommand) Extend() command.Extend {
 
 // Handle Execute the console command.
 func (r *MiddlewareMakeCommand) Handle(ctx console.Context) error {
-	make, err := supportconsole.NewMake(ctx, "middleware", ctx.Argument(0), support.Config.Paths.Middleware)
+	for _, name := range supportconsole.MakeNames(ctx) {
+		if err := r.makeOne(ctx, name); err != nil {
+			ctx.Error(err.Error())
+		}
+	}
+
+	return nil
+}
+
+func (r *MiddlewareMakeCommand) makeOne(ctx console.Context, name string) error {
+	make, err := supportconsole.NewMake(ctx, "middleware", name, support.Config.Paths.Middleware)
 	if err != nil {
-		ctx.Error(err.Error())
-		return nil
+		return err
 	}
 
 	if err := file.PutContent(make.GetFilePath(), r.populateStub(r.getStub(), make.GetPackageName(), make.GetStructName())); err != nil {
-		ctx.Error(err.Error())
-		return nil
+		return err
 	}
 
 	ctx.Success("Middleware created successfully")

http/console/middleware_make_command_test.go

@@ -14,23 +14,23 @@ import (
 func TestMiddlewareMakeCommand(t *testing.T) {
 	middlewareMakeCommand := &MiddlewareMakeCommand{}
 	mockContext := mocksconsole.NewContext(t)
-	mockContext.EXPECT().Argument(0).Return("").Once()
+	mockContext.EXPECT().Arguments().Return(nil).Once()
 	mockContext.EXPECT().Ask("Enter the middleware name", mock.Anything).Return("", errors.New("the middleware name cannot be empty")).Once()
 	mockContext.EXPECT().Error("the middleware name cannot be empty").Once()
 	assert.NoError(t, middlewareMakeCommand.Handle(mockContext))
 
-	mockContext.EXPECT().Argument(0).Return("VerifyCsrfToken").Once()
+	mockContext.EXPECT().Arguments().Return([]string{"VerifyCsrfToken"}).Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Success("Middleware created successfully").Once()
 	assert.NoError(t, middlewareMakeCommand.Handle(mockContext))
 	assert.True(t, file.Exists("app/http/middleware/verify_csrf_token.go"))
 
-	mockContext.EXPECT().Argument(0).Return("VerifyCsrfToken").Once()
+	mockContext.EXPECT().Arguments().Return([]string{"VerifyCsrfToken"}).Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Error("the middleware already exists. Use the --force or -f flag to overwrite").Once()
 	assert.NoError(t, middlewareMakeCommand.Handle(mockContext))
 
-	mockContext.EXPECT().Argument(0).Return("User/Auth").Once()
+	mockContext.EXPECT().Arguments().Return([]string{"User/Auth"}).Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Success("Middleware created successfully").Once()
 	assert.NoError(t, middlewareMakeCommand.Handle(mockContext))
@@ -39,3 +39,18 @@ func TestMiddlewareMakeCommand(t *testing.T) {
 	assert.True(t, file.Contain("app/http/middleware/User/auth.go", "func Auth() http.Middleware {"))
 	assert.Nil(t, file.Remove("app"))
 }
+
+func TestMiddlewareMakeCommand_MultipleNames(t *testing.T) {
+	middlewareMakeCommand := &MiddlewareMakeCommand{}
+	mockContext := mocksconsole.NewContext(t)
+
+	mockContext.EXPECT().Arguments().Return([]string{"Authenticate", "Throttle"}).Once()
+	mockContext.EXPECT().OptionBool("force").Return(false).Times(2)
+	mockContext.EXPECT().Success("Middleware created successfully").Times(2)
+
+	assert.NoError(t, middlewareMakeCommand.Handle(mockContext))
+
+	assert.True(t, file.Exists("app/http/middleware/authenticate.go"))
+	assert.True(t, file.Exists("app/http/middleware/throttle.go"))
+	assert.Nil(t, file.Remove("app"))
+}

http/console/request_make_command.go

@@ -39,15 +39,23 @@ func (r *RequestMakeCommand) Extend() command.Extend {
 
 // Handle Execute the console command.
 func (r *RequestMakeCommand) Handle(ctx console.Context) error {
-	m, err := supportconsole.NewMake(ctx, "request", ctx.Argument(0), support.Config.Paths.Requests)
+	for _, name := range supportconsole.MakeNames(ctx) {
+		if err := r.makeOne(ctx, name); err != nil {
+			ctx.Error(err.Error())
+		}
+	}
+
+	return nil
+}
+
+func (r *RequestMakeCommand) makeOne(ctx console.Context, name string) error {
+	m, err := supportconsole.NewMake(ctx, "request", name, support.Config.Paths.Requests)
 	if err != nil {
-		ctx.Error(err.Error())
-		return nil
+		return err
 	}
 
 	if err = file.PutContent(m.GetFilePath(), r.populateStub(r.getStub(), m.GetPackageName(), m.GetStructName())); err != nil {
-		ctx.Error(err.Error())
-		return nil
+		return err
 	}
 
 	ctx.Success("Request created successfully")

http/console/request_make_command_test.go

@@ -14,23 +14,23 @@ import (
 func TestRequestMakeCommand(t *testing.T) {
 	requestMakeCommand := &RequestMakeCommand{}
 	mockContext := mocksconsole.NewContext(t)
-	mockContext.EXPECT().Argument(0).Return("").Once()
+	mockContext.EXPECT().Arguments().Return(nil).Once()
 	mockContext.EXPECT().Ask("Enter the request name", mock.Anything).Return("", errors.New("the request name cannot be empty")).Once()
 	mockContext.EXPECT().Error("the request name cannot be empty").Once()
 	assert.NoError(t, requestMakeCommand.Handle(mockContext))
 
-	mockContext.EXPECT().Argument(0).Return("CreateUser").Once()
+	mockContext.EXPECT().Arguments().Return([]string{"CreateUser"}).Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Success("Request created successfully").Once()
 	assert.NoError(t, requestMakeCommand.Handle(mockContext))
 	assert.True(t, file.Exists("app/http/requests/create_user.go"))
 
-	mockContext.EXPECT().Argument(0).Return("CreateUser").Once()
+	mockContext.EXPECT().Arguments().Return([]string{"CreateUser"}).Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Error("the request already exists. Use the --force or -f flag to overwrite").Once()
 	assert.NoError(t, requestMakeCommand.Handle(mockContext))
 
-	mockContext.EXPECT().Argument(0).Return("User/Auth").Once()
+	mockContext.EXPECT().Arguments().Return([]string{"User/Auth"}).Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Success("Request created successfully").Once()
 	assert.NoError(t, requestMakeCommand.Handle(mockContext))
@@ -39,3 +39,18 @@ func TestRequestMakeCommand(t *testing.T) {
 	assert.True(t, file.Contain("app/http/requests/User/auth.go", "type Auth struct"))
 	assert.Nil(t, file.Remove("app"))
 }
+
+func TestRequestMakeCommand_MultipleNames(t *testing.T) {
+	requestMakeCommand := &RequestMakeCommand{}
+	mockContext := mocksconsole.NewContext(t)
+
+	mockContext.EXPECT().Arguments().Return([]string{"StoreUser", "UpdateUser"}).Once()
+	mockContext.EXPECT().OptionBool("force").Return(false).Times(2)
+	mockContext.EXPECT().Success("Request created successfully").Times(2)
+
+	assert.NoError(t, requestMakeCommand.Handle(mockContext))
+
+	assert.True(t, file.Exists("app/http/requests/store_user.go"))
+	assert.True(t, file.Exists("app/http/requests/update_user.go"))
+	assert.Nil(t, file.Remove("app"))
+}