refactor: remove features/ from domain/

cmd/new_module.go

@@ -13,8 +13,8 @@ import (
 )
 
 var newModuleCmd = &cobra.Command{
-	Use:   "gen features [name]",
-	Short: "Create a new features",
+	Use:   "gen module [name]",
+	Short: "Create a new domain",
 	Args:  cobra.MaximumNArgs(2),
 	Run:   createModule,
 }
@@ -35,7 +35,7 @@ func createModule(_ *cobra.Command, args []string) {
 		fmt.Println("Error finding Git root:", err)
 		return
 	}
-	mainModulePath := filepath.Join(projectPath, "domain", "features", "module.go")
+	mainModulePath := filepath.Join(projectPath, "domain", "module.go")
 	var moduleName string
 	if len(args) == 1 {
 		questions := []terminal.ProjectQuestion{
@@ -59,7 +59,7 @@ func createModule(_ *cobra.Command, args []string) {
 	data := utility.GetModuleDataFromModuleName(moduleName, projectModule.Module, projectModule.GoVersion)
 
 	// Define the directory structure
-	targetRoot := filepath.Join(".", "domain", "features", data.PackageName)
+	targetRoot := filepath.Join(".", "domain", data.PackageName)
 	templatePath := filepath.Join(".", "templates", "wesionary", "module")
 
 	err = utility.GenerateFiles(templatesFS, templatePath, targetRoot, data)

domain/hello/route.go

@@ -0,0 +1,23 @@
+package hello
+
+import (
+  "github.com/gin-gonic/gin"
+  "test/pkg/infrastructure"
+)
+
+type HelloRoute struct {
+    router *infrastructure.Router
+    controller *HelloController
+    groupRouter *gin.RouterGroup
+}
+
+func NewHelloRoute(router *infrastructure.Router, controller *HelloController) *HelloRoute {
+	route := HelloRoute{router: router, controller: controller}
+  route.groupRouter = route.router.Group("api/hello")
+	route.RegisterHelloRoutes()
+	return &route
+}
+
+func (r *HelloRoute) RegisterHelloRoutes() {
+	r.groupRouter.GET("", r.controller.HandleRoot)
+}

domain/middlewares/module.go

@@ -0,0 +1,5 @@
+package middlewares
+
+import "go.uber.org/fx"
+
+var Module = fx.Module("domain-middlewares", fx.Options())

domain/module.go

@@ -0,0 +1,13 @@
+package domain
+
+import (
+	"test/domain/hello"
+	"test/domain/middlewares"
+
+	"go.uber.org/fx"
+)
+
+var Module = fx.Options(
+	middlewares.Module,
+	hello.Module,
+)

domain/user/controller.go

@@ -0,0 +1,19 @@
+package user
+
+import (
+    "net/http"
+    "github.com/gin-gonic/gin"
+)
+
+type UserController struct {
+    service *UserService
+}
+
+func NewUserController(service *UserService) *UserController {
+    return &UserController{service: service}
+}
+
+func (ctrl *UserController) HandleRoot(c *gin.Context) {
+    message := ctrl.service.GetMessage()
+    c.JSON(http.StatusOK, gin.H{"message": message.Message})
+}

domain/user/model.go

@@ -0,0 +1,5 @@
+package user
+
+type UserModel struct {
+    Message string
+}

domain/user/module.go

@@ -0,0 +1,16 @@
+package user
+
+import (
+    "go.uber.org/fx"
+)
+
+var Module = fx.Module("user",
+	fx.Options(
+		fx.Provide(
+			NewUserService,
+			NewUserController,
+			NewUserRepository,
+		),
+		fx.Invoke(NewUserRoute),
+	),
+)

domain/user/repository.go

@@ -0,0 +1,12 @@
+package user
+
+type UserRepository struct {
+}
+
+func NewUserRepository() *UserRepository {
+	return &UserRepository{}
+}
+
+func (s *UserRepository) GetMessage() UserModel {
+	return UserModel{Message: "Hello World"}
+}

domain/user/route.go

@@ -0,0 +1,23 @@
+package user
+
+import (
+  "github.com/gin-gonic/gin"
+  "github.com/mukezhz/geng/pkg/infrastructure"
+)
+
+type UserRoute struct {
+    router *infrastructure.Router
+    controller *UserController
+    groupRouter *gin.RouterGroup
+}
+
+func NewUserRoute(router *infrastructure.Router, controller *UserController) *UserRoute {
+	route := UserRoute{router: router, controller: controller}
+  route.groupRouter = router.Group("api/user")
+	route.RegisterHelloRoutes()
+	return &route
+}
+
+func (r *UserRoute) RegisterHelloRoutes() {
+	r.groupRouter.GET("", r.controller.HandleRoot)
+}

domain/user/service.go

@@ -0,0 +1,19 @@
+package user
+
+// UserService handles the business logic of the User module
+type UserService struct {
+	// Add any dependencies here
+	repo *UserRepository
+}
+
+// NewUserService creates a new instance of TestService
+func NewUserService(repo *UserRepository) *UserService {
+	return &UserService{
+		repo: repo,
+	}
+}
+
+// GetMessage returns a greeting message
+func (s *UserService) GetMessage() UserModel {
+	return s.repo.GetMessage()
+}

pkg/utility/ast.go

@@ -15,7 +15,7 @@ import (
 )
 
 func ImportPackage(node *ast.File, projectModule, packageName string) {
-	path := filepath.Join(projectModule, "domain", "features", packageName)
+	path := filepath.Join(projectModule, "domain", packageName)
 	importSpec := &ast.ImportSpec{
 		Path: &ast.BasicLit{
 			Kind:  token.STRING,
@@ -59,17 +59,10 @@ func AddAnotherFxOptionsInModule(path, module, projectModule string) string {
 		switch x := n.(type) {
 		case *ast.CallExpr:
 			if sel, ok := x.Fun.(*ast.SelectorExpr); ok {
-				if sel.Sel.Name == "Module" {
-					x.Args = append(x.Args, &ast.CallExpr{
-						Fun: &ast.SelectorExpr{
-							X:   ast.NewIdent("fx"),
-							Sel: ast.NewIdent("Options"),
-						},
-						Args: []ast.Expr{
-							ast.NewIdent(module + ".Module"),
-						},
-						Rparen: token.Pos(1),
-					})
+				if sel.Sel.Name == "Options" {
+					x.Args = append(x.Args, []ast.Expr{
+						ast.NewIdent(module + ".Module"),
+					}...)
 				}
 			}
 		}
@@ -82,7 +75,7 @@ func AddAnotherFxOptionsInModule(path, module, projectModule string) string {
 		fmt.Println(err)
 	}
 	formattedCode := buf.String()
-	providerToInsert := fmt.Sprintf("fx.Options(%v.Module),", module)
+	providerToInsert := fmt.Sprintf("%v.Module,", module)
 	formattedCode = strings.Replace(formattedCode, providerToInsert, "\n\t"+providerToInsert, 1)
 	return formattedCode
 }

templates/wesionary/project/domain/hello/controller.tmpl

@@ -0,0 +1,19 @@
+package hello
+
+import (
+    "net/http"
+    "github.com/gin-gonic/gin"
+)
+
+type HelloController struct {
+    service *HelloService
+}
+
+func NewHelloController(service *HelloService) *HelloController {
+    return &HelloController{service: service}
+}
+
+func (ctrl *HelloController) HandleRoot(c *gin.Context) {
+    message := ctrl.service.GetMessage()
+    c.JSON(http.StatusOK, gin.H{"message": message.Message})
+}

templates/wesionary/project/domain/hello/model.tmpl

@@ -0,0 +1,5 @@
+package hello
+
+type HelloModel struct {
+    Message string
+}

templates/wesionary/project/domain/hello/module.tmpl

@@ -0,0 +1,16 @@
+package hello
+
+import (
+    "go.uber.org/fx"
+)
+
+var Module = fx.Module("hello",
+	fx.Options(
+		fx.Provide(
+			NewHelloService,
+			NewHelloController,
+      		NewHelloRepository,
+		),
+		fx.Invoke(NewHelloRoute),
+	),
+)

templates/wesionary/project/domain/hello/repository.tmpl

@@ -0,0 +1,12 @@
+package hello
+
+type HelloRepository struct {
+}
+
+func NewHelloRepository() *HelloRepository {
+	return &HelloRepository{}
+}
+
+func (s *HelloRepository) GetMessage() HelloModel {
+	return HelloModel{Message: "Hello World"}
+}

templates/wesionary/project/domain/hello/service.tmpl

@@ -0,0 +1,19 @@
+package hello
+
+// HelloService handles the business logic of the Hello module
+type HelloService struct {
+	// Add any dependencies here
+	repo *HelloRepository
+}
+
+// NewHelloService creates a new instance of TestService
+func NewHelloService(repo *HelloRepository) *HelloService {
+	return &HelloService{
+		repo: repo,
+	}
+}
+
+// GetMessage returns a greeting message
+func (s *HelloService) GetMessage() HelloModel {
+	return s.repo.GetMessage()
+}

templates/wesionary/project/domain/module.tmpl

@@ -1,13 +1,13 @@
 package domain
 
 import (
-    "{{.ProjectModuleName}}/domain/features"
+    "{{.ProjectModuleName}}/domain/hello"
     "{{.ProjectModuleName}}/domain/middlewares"
 
     "go.uber.org/fx"
 )
 
 var Module = fx.Options(
 	middlewares.Module,
-	features.Module,
+	hello.Module,
 )