Cli/add service generation

.gitignore

@@ -7,4 +7,4 @@ coverage.out
 recipe.db
 bin
 go.work.sum
-fuego
+/cmd/fuego/fuego

cmd/fuego/commands/controller.go

@@ -18,46 +18,65 @@ func Controller() *cli.Command {
 		Usage:   "creates a new controller file",
 		Aliases: []string{"c"},
 		Action: func(cCtx *cli.Context) error {
-			controllerName := cCtx.Args().First()
+			entityName := cCtx.Args().First()
 
-			if controllerName == "" {
-				controllerName = "newController"
+			if entityName == "" {
+				entityName = "newEntity"
 				fmt.Println("Note: You can add a controller name as an argument. Example: `fuego controller books`")
 			}
 
-			_, err := createController(controllerName)
+			_, err := createNewEntityDomainFile(entityName, "entity.go", entityName+".go")
 			if err != nil {
 				return err
 			}
 
-			fmt.Printf("🔥 Controller %s created successfully\n", controllerName)
+			_, err = createNewEntityDomainFile(entityName, "controller.go", entityName+"Controller.go")
+			if err != nil {
+				return err
+			}
+
+			fmt.Printf("🔥 Controller %s created successfully\n", entityName)
 			return nil
 		},
+		Flags: []cli.Flag{
+			&cli.BoolFlag{
+				Name:  "with-service",
+				Usage: "enable service file generation",
+				Value: false,
+				Action: func(cCtx *cli.Context, shouldGenerateServiceFile bool) error {
+					if !shouldGenerateServiceFile {
+						return nil
+					}
+
+					return serviceCommandAction(cCtx)
+				},
+			},
+		},
 	}
 }
 
 // createController creates a new controller file
-func createController(controllerName string) (string, error) {
-	controllerDir := "./controller/"
+func createNewEntityDomainFile(entityName, controllerTemplateFileName, outputFileName string) (string, error) {
+	controllerDir := "./domains/" + entityName + "/"
 	if _, err := os.Stat(controllerDir); os.IsNotExist(err) {
-		err = os.Mkdir(controllerDir, 0o755)
+		err = os.MkdirAll(controllerDir, 0o755)
 		if err != nil {
 			return "", err
 		}
 	}
 
-	templateContent, err := templates.FS.ReadFile("controller/controller.go")
+	templateContent, err := templates.FS.ReadFile("newEntity/" + controllerTemplateFileName)
 	if err != nil {
 		return "", err
 	}
 
 	t := language.English
 	titler := cases.Title(t)
 
-	newContent := strings.ReplaceAll(string(templateContent), "newController", controllerName)
-	newContent = strings.ReplaceAll(newContent, "NewController", titler.String(controllerName))
+	newContent := strings.ReplaceAll(string(templateContent), "newEntity", entityName)
+	newContent = strings.ReplaceAll(newContent, "NewEntity", titler.String(entityName))
 
-	controllerPath := fmt.Sprintf("%s%s.go", controllerDir, controllerName)
+	controllerPath := fmt.Sprintf("%s%s", controllerDir, outputFileName)
 
 	err = os.WriteFile(controllerPath, []byte(newContent), 0o644)
 	if err != nil {

cmd/fuego/commands/controller_test.go

@@ -8,7 +8,7 @@ import (
 )
 
 func TestCreateController(t *testing.T) {
-	res, err := createController("books")
+	res, err := createNewEntityDomainFile("books", "controller.go", "booksController.go")
 	require.NoError(t, err)
 	require.Contains(t, res, "package controller")
 	require.Contains(t, res, `fuego.Get(booksGroup, "/{id}", rs.getBooks)`)

cmd/fuego/commands/service.go

@@ -0,0 +1,38 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/urfave/cli/v2"
+)
+
+func Service() *cli.Command {
+	return &cli.Command{
+		Name:    "service",
+		Usage:   "creates a new service file",
+		Aliases: []string{"s"},
+		Action:  serviceCommandAction,
+	}
+}
+
+func serviceCommandAction(cCtx *cli.Context) error {
+	entityName := cCtx.Args().First()
+
+	if entityName == "" {
+		entityName = "newController"
+		fmt.Println("Note: You can add an entity name as an argument. Example: `fuego service books`")
+	}
+
+	_, err := createNewEntityDomainFile(entityName, "entity.go", entityName+".go")
+	if err != nil {
+		return err
+	}
+
+	_, err = createNewEntityDomainFile(entityName, "service.go", entityName+"Service.go")
+	if err != nil {
+		return err
+	}
+
+	fmt.Printf("🔥 Service %s created successfully\n", entityName)
+	return nil
+}

cmd/fuego/main.go

@@ -20,6 +20,7 @@ func main() {
 		},
 		Commands: []*cli.Command{
 			commands.Controller(),
+			commands.Service(),
 		},
 	}
 

cmd/fuego/templates/newEntity/controller.go

@@ -0,0 +1,65 @@
+package newEntity
+
+import (
+	"github.com/go-fuego/fuego"
+)
+
+type NewEntityResources struct {
+	// TODO add resources
+	NewEntityService NewEntityService
+}
+
+func (rs NewEntityResources) Routes(s *fuego.Server) {
+	newEntityGroup := fuego.Group(s, "/newEntity")
+
+	fuego.Get(newEntityGroup, "/", rs.getAllNewEntity)
+	fuego.Post(newEntityGroup, "/", rs.postNewEntity)
+
+	fuego.Get(newEntityGroup, "/{id}", rs.getNewEntity)
+	fuego.Put(newEntityGroup, "/{id}", rs.putNewEntity)
+	fuego.Delete(newEntityGroup, "/{id}", rs.deleteNewEntity)
+}
+
+func (rs NewEntityResources) getAllNewEntity(c fuego.ContextNoBody) ([]NewEntity, error) {
+	return rs.NewEntityService.GetAllNewEntity()
+}
+
+func (rs NewEntityResources) postNewEntity(c *fuego.ContextWithBody[NewEntityCreate]) (NewEntity, error) {
+	body, err := c.Body()
+	if err != nil {
+		return NewEntity{}, err
+	}
+
+	new, err := rs.NewEntityService.CreateNewEntity(body)
+	if err != nil {
+		return NewEntity{}, err
+	}
+
+	return new, nil
+}
+
+func (rs NewEntityResources) getNewEntity(c fuego.ContextNoBody) (NewEntity, error) {
+	id := c.PathParam("id")
+
+	return rs.NewEntityService.GetNewEntity(id)
+}
+
+func (rs NewEntityResources) putNewEntity(c *fuego.ContextWithBody[NewEntityUpdate]) (NewEntity, error) {
+	id := c.PathParam("id")
+
+	body, err := c.Body()
+	if err != nil {
+		return NewEntity{}, err
+	}
+
+	new, err := rs.NewEntityService.UpdateNewEntity(id, body)
+	if err != nil {
+		return NewEntity{}, err
+	}
+
+	return new, nil
+}
+
+func (rs NewEntityResources) deleteNewEntity(c *fuego.ContextNoBody) (any, error) {
+	return rs.NewEntityService.DeleteNewEntity(c.PathParam("id"))
+}

cmd/fuego/templates/newEntity/entity.go

@@ -0,0 +1,22 @@
+package newEntity
+
+type NewEntity struct {
+	ID   string `json:"id"`
+	Name string `json:"name"`
+}
+
+type NewEntityCreate struct {
+	Name string `json:"name"`
+}
+
+type NewEntityUpdate struct {
+	Name string `json:"name"`
+}
+
+type NewEntityService interface {
+	GetNewEntity(id string) (NewEntity, error)
+	CreateNewEntity(NewEntityCreate) (NewEntity, error)
+	GetAllNewEntity() ([]NewEntity, error)
+	UpdateNewEntity(id string, input NewEntityUpdate) (NewEntity, error)
+	DeleteNewEntity(id string) (any, error)
+}