feat: modular (ddd) implementation

.gitignore

@@ -3,4 +3,5 @@
 .vscode
 /vendor
 coverage.out
-.opencode
+.opencode
+/tmp

ai/console/agent_make_command.go

@@ -33,6 +33,7 @@ func (r *AgentMakeCommand) Extend() command.Extend {
 				Aliases: []string{"f"},
 				Usage:   "Create the agent even if it already exists",
 			},
+			supportconsole.ModuleFlag(),
 		},
 	}
 }

ai/console/agent_make_command_test.go

@@ -28,7 +28,7 @@ func TestAgentMakeCommand(t *testing.T) {
 
 	extend := agentMakeCommand.Extend()
 	assert.Equal(t, "make", extend.Category)
-	if assert.Len(t, extend.Flags, 1) {
+	if assert.Len(t, extend.Flags, 2) {
 		flag, ok := extend.Flags[0].(*command.BoolFlag)
 		assert.True(t, ok)
 		if ok {
@@ -44,17 +44,20 @@ func TestAgentMakeCommand(t *testing.T) {
 	assert.NoError(t, agentMakeCommand.Handle(mockContext))
 
 	mockContext.EXPECT().Arguments().Return([]string{"UserAgent"}).Once()
+	mockContext.EXPECT().Option("module").Return("").Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Success("Agent created successfully").Once()
 	assert.NoError(t, agentMakeCommand.Handle(mockContext))
 	assert.True(t, file.Exists("app/ai/agents/user_agent.go"))
 
 	mockContext.EXPECT().Arguments().Return([]string{"UserAgent"}).Once()
+	mockContext.EXPECT().Option("module").Return("").Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Error("the agent already exists. Use the --force or -f flag to overwrite").Once()
 	assert.NoError(t, agentMakeCommand.Handle(mockContext))
 
 	mockContext.EXPECT().Arguments().Return([]string{"user/SupportAgent"}).Once()
+	mockContext.EXPECT().Option("module").Return("").Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Success("Agent created successfully").Once()
 	assert.NoError(t, agentMakeCommand.Handle(mockContext))
@@ -67,6 +70,7 @@ func TestAgentMakeCommand(t *testing.T) {
 
 	support.Config.Paths.Agents = "custom/agents"
 	mockContext.EXPECT().Arguments().Return([]string{"BillingAgent"}).Once()
+	mockContext.EXPECT().Option("module").Return("").Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Success("Agent created successfully").Once()
 	assert.NoError(t, agentMakeCommand.Handle(mockContext))
@@ -81,6 +85,7 @@ func TestAgentMakeCommand_MultipleNames(t *testing.T) {
 	}()
 
 	mockContext.EXPECT().Arguments().Return([]string{"SupportAgent", "BillingAgent"}).Once()
+	mockContext.EXPECT().Option("module").Return("").Times(2)
 	mockContext.EXPECT().OptionBool("force").Return(false).Times(2)
 	mockContext.EXPECT().Success("Agent created successfully").Times(2)
 	assert.NoError(t, agentMakeCommand.Handle(mockContext))

ai/console/tool_make_command.go

@@ -34,6 +34,7 @@ func (r *ToolMakeCommand) Extend() command.Extend {
 				Aliases: []string{"f"},
 				Usage:   "Create the tool even if it already exists",
 			},
+			supportconsole.ModuleFlag(),
 		},
 	}
 }

ai/console/tool_make_command_test.go

@@ -28,7 +28,7 @@ func TestToolMakeCommand(t *testing.T) {
 
 	extend := toolMakeCommand.Extend()
 	assert.Equal(t, "make", extend.Category)
-	if assert.Len(t, extend.Flags, 1) {
+	if assert.Len(t, extend.Flags, 2) {
 		flag, ok := extend.Flags[0].(*command.BoolFlag)
 		assert.True(t, ok)
 		if ok {
@@ -44,17 +44,20 @@ func TestToolMakeCommand(t *testing.T) {
 	assert.NoError(t, toolMakeCommand.Handle(mockContext))
 
 	mockContext.EXPECT().Arguments().Return([]string{"WeatherTool"}).Once()
+	mockContext.EXPECT().Option("module").Return("").Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Success("Tool created successfully").Once()
 	assert.NoError(t, toolMakeCommand.Handle(mockContext))
 	assert.True(t, file.Exists("app/ai/tools/weather_tool.go"))
 
 	mockContext.EXPECT().Arguments().Return([]string{"WeatherTool"}).Once()
+	mockContext.EXPECT().Option("module").Return("").Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Error("the tool already exists. Use the --force or -f flag to overwrite").Once()
 	assert.NoError(t, toolMakeCommand.Handle(mockContext))
 
 	mockContext.EXPECT().Arguments().Return([]string{"user/WeatherTool"}).Once()
+	mockContext.EXPECT().Option("module").Return("").Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Success("Tool created successfully").Once()
 	assert.NoError(t, toolMakeCommand.Handle(mockContext))
@@ -71,6 +74,7 @@ func TestToolMakeCommand(t *testing.T) {
 
 	support.Config.Paths.Tools = "custom/tools"
 	mockContext.EXPECT().Arguments().Return([]string{"CurrencyTool"}).Once()
+	mockContext.EXPECT().Option("module").Return("").Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Success("Tool created successfully").Once()
 	assert.NoError(t, toolMakeCommand.Handle(mockContext))
@@ -85,6 +89,7 @@ func TestToolMakeCommand_MultipleNames(t *testing.T) {
 	}()
 
 	mockContext.EXPECT().Arguments().Return([]string{"WeatherTool", "CurrencyTool"}).Once()
+	mockContext.EXPECT().Option("module").Return("").Times(2)
 	mockContext.EXPECT().OptionBool("force").Return(false).Times(2)
 	mockContext.EXPECT().Success("Tool created successfully").Times(2)
 	assert.NoError(t, toolMakeCommand.Handle(mockContext))

auth/console/module_flag_test.go

@@ -0,0 +1,28 @@
+package console
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/goravel/framework/contracts/console"
+	"github.com/goravel/framework/contracts/console/command"
+)
+
+// Every make command of the package accepts --module.
+func TestMakeCommands_ModuleFlag(t *testing.T) {
+	commands := []console.Command{
+		NewPolicyMakeCommand(),
+	}
+
+	for _, cmd := range commands {
+		var names []string
+		for _, flag := range cmd.Extend().Flags {
+			if f, ok := flag.(*command.StringFlag); ok {
+				names = append(names, f.Name)
+			}
+		}
+
+		assert.Contains(t, names, "module", cmd.Signature())
+	}
+}

auth/console/policy_make_command.go

@@ -37,6 +37,7 @@ func (r *PolicyMakeCommand) Extend() command.Extend {
 				Aliases: []string{"f"},
 				Usage:   "Create the policy even if it already exists",
 			},
+			supportconsole.ModuleFlag(),
 		},
 	}
 }

auth/console/policy_make_command_test.go

@@ -20,17 +20,20 @@ func TestPolicyMakeCommand(t *testing.T) {
 	assert.Nil(t, policyMakeCommand.Handle(mockContext))
 
 	mockContext.EXPECT().Arguments().Return([]string{"UserPolicy"}).Once()
+	mockContext.EXPECT().Option("module").Return("").Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Success("Policy created successfully").Once()
 	assert.Nil(t, policyMakeCommand.Handle(mockContext))
 	assert.True(t, file.Exists("app/policies/user_policy.go"))
 
 	mockContext.EXPECT().Arguments().Return([]string{"UserPolicy"}).Once()
+	mockContext.EXPECT().Option("module").Return("").Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Error("the policy already exists. Use the --force or -f flag to overwrite").Once()
 	assert.Nil(t, policyMakeCommand.Handle(mockContext))
 
 	mockContext.EXPECT().Arguments().Return([]string{"User/AuthPolicy"}).Once()
+	mockContext.EXPECT().Option("module").Return("").Once()
 	mockContext.EXPECT().OptionBool("force").Return(false).Once()
 	mockContext.EXPECT().Success("Policy created successfully").Once()
 	assert.Nil(t, policyMakeCommand.Handle(mockContext))
@@ -50,6 +53,7 @@ func TestPolicyMakeCommand_MultipleNames(t *testing.T) {
 	mockContext := mocksconsole.NewContext(t)
 
 	mockContext.EXPECT().Arguments().Return([]string{"PostPolicy", "CommentPolicy"}).Once()
+	mockContext.EXPECT().Option("module").Return("").Times(2)
 	mockContext.EXPECT().OptionBool("force").Return(false).Times(2)
 	mockContext.EXPECT().Success("Policy created successfully").Times(2)
 	assert.Nil(t, policyMakeCommand.Handle(mockContext))

broadcasting/console/channel_make_command.go

@@ -33,6 +33,7 @@ func (r *ChannelMakeCommand) Extend() command.Extend {
 				Aliases: []string{"f"},
 				Usage:   "Create the channel even if it already exists",
 			},
+			supportconsole.ModuleFlag(),
 		},
 	}
 }

broadcasting/console/channel_make_command_test.go

@@ -30,6 +30,7 @@ func TestChannelMakeCommand(t *testing.T) {
 	t.Run("success", func(t *testing.T) {
 		mockContext := mocksconsole.NewContext(t)
 		mockContext.EXPECT().Arguments().Return([]string{"TestChannel"}).Once()
+		mockContext.EXPECT().Option("module").Return("").Once()
 		mockContext.EXPECT().OptionBool("force").Return(false).Once()
 		mockContext.EXPECT().Success("Channel created successfully").Once()
 		assert.Nil(t, cmd.Handle(mockContext))
@@ -51,6 +52,7 @@ func TestChannelMakeCommand_MultipleNames(t *testing.T) {
 	mockContext := mocksconsole.NewContext(t)
 
 	mockContext.EXPECT().Arguments().Return([]string{"OrderChannel", "UserChannel"}).Once()
+	mockContext.EXPECT().Option("module").Return("").Times(2)
 	mockContext.EXPECT().OptionBool("force").Return(false).Times(2)
 	mockContext.EXPECT().Success("Channel created successfully").Times(2)
 	assert.Nil(t, cmd.Handle(mockContext))

broadcasting/console/module_flag_test.go

@@ -0,0 +1,28 @@
+package console
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/goravel/framework/contracts/console"
+	"github.com/goravel/framework/contracts/console/command"
+)
+
+// Every make command of the package accepts --module.
+func TestMakeCommands_ModuleFlag(t *testing.T) {
+	commands := []console.Command{
+		NewChannelMakeCommand(),
+	}
+
+	for _, cmd := range commands {
+		var names []string
+		for _, flag := range cmd.Extend().Flags {
+			if f, ok := flag.(*command.StringFlag); ok {
+				names = append(names, f.Name)
+			}
+		}
+
+		assert.Contains(t, names, "module", cmd.Signature())
+	}
+}

console/console/make_command.go

@@ -46,6 +46,7 @@ func (r *MakeCommand) Extend() command.Extend {
 				Usage:              "Create the command even if it already exists",
 				DisableDefaultText: true,
 			},
+			supportconsole.ModuleFlag(),
 		},
 	}
 }
@@ -69,7 +70,9 @@ func (r *MakeCommand) makeOne(ctx console.Context, name string) error {
 
 	ctx.Success("Console command created successfully")
 
-	if env.IsBootstrapSetup() {
+	if dir := make.GetModuleDir(); dir != "" {
+		err = modify.AddToModule(dir, "Commands", make.GetPackageImportPath(), fmt.Sprintf("&%s.%s{}", make.GetPackageName(), make.GetStructName()))
+	} else if env.IsBootstrapSetup() {
 		err = modify.AddCommand(make.GetPackageImportPath(), fmt.Sprintf("&%s.%s{}", make.GetPackageName(), make.GetStructName()))
 	} else {
 		err = r.registerInKernel(make)

console/console/make_command_hook.go

@@ -48,6 +48,7 @@ func (r *MakeCommandHook) Extend() command.Extend {
 				Aliases: []string{"c"},
 				Usage:   "The command signature or '*' pattern the hook runs for, default is '*'",
 			},
+			supportconsole.ModuleFlag(),
 		},
 	}
 }

console/console/make_command_hook_test.go

@@ -118,6 +118,7 @@ func TestMakeCommandHook(t *testing.T) {
 		mockContext := mocksconsole.NewContext(t)
 		mockContext.EXPECT().Option("command").Return("").Once()
 		mockContext.EXPECT().Arguments().Return([]string{"AuditLog"}).Once()
+		mockContext.EXPECT().Option("module").Return("").Once()
 		mockContext.EXPECT().OptionBool("force").Return(false).Once()
 		mockContext.EXPECT().Error("the command hook already exists. Use the --force or -f flag to overwrite").Once()
 
@@ -130,6 +131,7 @@ func TestMakeCommandHook(t *testing.T) {
 		mockContext := mocksconsole.NewContext(t)
 		mockContext.EXPECT().Option("command").Return("*").Once()
 		mockContext.EXPECT().Arguments().Return([]string{"AuditLog"}).Once()
+		mockContext.EXPECT().Option("module").Return("").Once()
 		mockContext.EXPECT().OptionBool("force").Return(true).Once()
 		mockContext.EXPECT().Success("Command hook created successfully").Once()
 		mockContext.EXPECT().Warning(mock.Anything).Once()
@@ -145,6 +147,7 @@ func TestMakeCommandHook(t *testing.T) {
 		mockContext.EXPECT().Option("command").Return("").Once()
 		mockContext.EXPECT().Arguments().Return([]string{"AuditLog"}).Once()
 		mockContext.EXPECT().Ask("Enter the command signature the hook runs for", mock.Anything).Return("*", nil).Once()
+		mockContext.EXPECT().Option("module").Return("").Once()
 		mockContext.EXPECT().OptionBool("force").Return(false).Once()
 		mockContext.EXPECT().Success("Command hook created successfully").Once()
 		mockContext.EXPECT().Warning("Command hook created but not registered, add it to WithCommandHooks in bootstrap/app.go manually").Once()
@@ -168,6 +171,7 @@ func TestMakeCommandHook(t *testing.T) {
 		mockContext := mocksconsole.NewContext(t)
 		mockContext.EXPECT().Option("command").Return("migrate").Once()
 		mockContext.EXPECT().Arguments().Return([]string{"AuditLog"}).Once()
+		mockContext.EXPECT().Option("module").Return("").Once()
 		mockContext.EXPECT().OptionBool("force").Return(false).Once()
 		mockContext.EXPECT().Success("Command hook created successfully").Once()
 		mockContext.EXPECT().Success("Command hook registered successfully").Once()
@@ -191,6 +195,7 @@ func TestMakeCommandHook(t *testing.T) {
 		mockContext := mocksconsole.NewContext(t)
 		mockContext.EXPECT().Option("command").Return("migrate").Once()
 		mockContext.EXPECT().Arguments().Return([]string{"AuditLog"}).Once()
+		mockContext.EXPECT().Option("module").Return("").Once()
 		mockContext.EXPECT().OptionBool("force").Return(false).Once()
 		mockContext.EXPECT().Success("Command hook created successfully").Once()
 		mockContext.EXPECT().Success("Command hook registered successfully").Once()
@@ -217,6 +222,7 @@ func TestMakeCommandHook(t *testing.T) {
 		mockContext := mocksconsole.NewContext(t)
 		mockContext.EXPECT().Option("command").Return("migrate").Once()
 		mockContext.EXPECT().Arguments().Return([]string{"AuditLog"}).Once()
+		mockContext.EXPECT().Option("module").Return("").Once()
 		mockContext.EXPECT().OptionBool("force").Return(false).Once()
 		mockContext.EXPECT().Success("Command hook created successfully").Once()
 		mockContext.EXPECT().Success("Command hook registered successfully").Once()
@@ -242,6 +248,7 @@ func TestMakeCommandHook(t *testing.T) {
 		mockContext := mocksconsole.NewContext(t)
 		mockContext.EXPECT().Option("command").Return("migrate").Once()
 		mockContext.EXPECT().Arguments().Return([]string{"AuditLog"}).Once()
+		mockContext.EXPECT().Option("module").Return("").Once()
 		mockContext.EXPECT().OptionBool("force").Return(false).Once()
 		mockContext.EXPECT().Success("Command hook created successfully").Once()
 		mockContext.EXPECT().Error(mock.MatchedBy(func(message string) bool {
@@ -259,6 +266,7 @@ func TestMakeCommandHook(t *testing.T) {
 		mockContext := mocksconsole.NewContext(t)
 		mockContext.EXPECT().Option("command").Return("migrate").Once()
 		mockContext.EXPECT().Arguments().Return([]string{"AuditLog", "SlowQuery"}).Once()
+		mockContext.EXPECT().Option("module").Return("").Times(2)
 		mockContext.EXPECT().OptionBool("force").Return(false).Times(2)
 		mockContext.EXPECT().Success("Command hook created successfully").Times(2)
 		mockContext.EXPECT().Success("Command hook registered successfully").Times(2)