v0.3.0

introduce --force flag

add staged project generation and overwrite protection

add project testing

correct graphQL handler

update CI

update README

update Makefile

fix duplicate code

Author: andrearcaina

.github/workflows/goforge-ci.yml

@@ -17,11 +17,8 @@ jobs:
               with:
                   go-version: "1.24.5"
 
-            - name: Verify dependencies
-              run: go mod verify
-
-            - name: Build
-              run: make build
+            - name: Verify deps, run tests, vet, lint, and build
+              run: make check
 
             - name: Version Check
               run: ./bin/goforge version

Makefile

@@ -1,4 +1,4 @@
-.PHONY: default build run clean
+.PHONY: default build test verify vet lint check run clean
 
 default:
 	echo "Opinionated Go CLI for generating backend service boilerplate"
@@ -7,8 +7,22 @@ build:
 	go build -o bin/goforge main.go
 	chmod +x bin/goforge
 
-run:
-	bash -c "./bin/goforge"
+test:
+	go test ./...
+
+verify:
+	go mod verify
+
+vet:
+	go vet ./...
+
+lint:
+	golangci-lint run ./...
+
+check: verify test vet lint build
+
+run: build
+	./bin/goforge
 
 clean:
 	rm -rf ./bin/**

README.md

@@ -68,14 +68,27 @@ const (
 )
 
 type Form struct {
-	Name           string
-	ServerTypeFlag ServerTypeFlag
-	DatabaseFlag   bool
-	MakefileFlag   bool
+    Name           string
+    ServerTypeFlag ServerTypeFlag
+    DatabaseFlag   bool
+    MakefileFlag   bool
+    DockerFlag     bool
 }
 ```
 
-If all required flags are provided (including `--database`), the TUI is skipped and the server is generated immediately.
+For non-interactive use (without opening the TUI options), explicitly provide each boolean option, including false values:
+
+```bash
+goforge generate \
+  --path rest-server \
+  --name my-server \
+  --server rest \
+  --database=false \
+  --makefile=true \
+  --docker=false
+```
+
+Docker generation requires database generation. If a generated file already exists, `goforge` preserves it and returns an error; pass `--force` to explicitly replace generated files.
 
 For example, running with all required flags will produce:
 ![goforge all flags](images/goforge-all-flags.png)
@@ -85,10 +98,10 @@ Here is an example where you can trigger the TUI:\
 
 ### Roadmap
 
-- [X] Allow different server type boilerplates
+- [x] Allow different server type boilerplates
     - [x] REST (`go-chi`)
     - [x] gRPC (`grpc-go`)
-    - [X] GraphQL (`gqlgen`)
+    - [x] GraphQL (`gqlgen`)
 - [x] Add Makefile support flag
 - [x] Add SQLc/database support flag
     - [x] Potentially add a docker-compose file to spin up a PostgreSQL instance

cmd/generate.go

@@ -1,12 +1,6 @@
-/*
-Copyright © 2026 NAME HERE <EMAIL ADDRESS>
-*/
 package cmd
 
 import (
-	"fmt"
-	"os"
-	"regexp"
 	"strings"
 
 	"github.com/andrearcaina/goforge/internal/config"
@@ -19,26 +13,21 @@ var cfg config.Config
 // generateCmd represents the generate command
 var generateCmd = &cobra.Command{
 	Use:   "generate",
-	Short: "Generate a hello world message",
-	Long: `Generates a simple hello world message using the provided flag.
-For example:
+	Short: "Generate a Go backend service",
+	Long: `Generate a REST, gRPC, or GraphQL Go backend service.
 
-goforge generate --some-flag "Developer"`,
+Missing options are collected through an interactive form.`,
+	Args: cobra.NoArgs,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		if err := goforge.Forge(&cfg); err != nil {
-			return err
-		}
-
-		return nil
+		return goforge.Forge(&cfg)
 	},
 }
 
 func init() {
-	rootCmd.AddCommand(generateCmd)
-
 	// general flags
 	generateCmd.Flags().StringVarP(&cfg.OutputPath, "path", "p", ".", "The directory to write the generated file to")
 	generateCmd.Flags().BoolVarP(&cfg.Default, "default", "d", false, "Use default configuration values")
+	generateCmd.Flags().BoolVarP(&cfg.Force, "force", "f", false, "Overwrite generated files that already exist")
 
 	// flags for form fields
 	generateCmd.Flags().StringVarP(&cfg.Form.Name, "name", "n", "", "The name for the go.mod module")
@@ -48,16 +37,13 @@ func init() {
 	generateCmd.Flags().BoolVarP(&cfg.Form.DockerFlag, "docker", "D", false, "Generate Docker Compose (for DB) and .env file (if flag is set, set to true)")
 
 	// normalize server type flag to lowercase
-	generateCmd.PreRun = func(cmd *cobra.Command, args []string) {
-		// first convert to string, then lowercase the string, then convert back to ServerTypeFlag
-		cfg.Form.ServerTypeFlag = config.ServerTypeFlag(strings.ToLower(string(cfg.Form.ServerTypeFlag)))
-
-		// validate go.mod names
-		if cfg.Form.Name != "" {
-			if matched, _ := regexp.MatchString(`[^a-zA-Z0-9_\-]`, cfg.Form.Name); matched {
-				fmt.Println("Error: project name can only contain letters, numbers, underscores, or dashes")
-				os.Exit(1)
-			}
-		}
+	generateCmd.PreRunE = func(cmd *cobra.Command, args []string) error {
+		cfg.Form.ServerTypeFlag = config.ServerTypeFlag(strings.ToLower(strings.TrimSpace(string(cfg.Form.ServerTypeFlag))))
+		cfg.Form.Name = strings.TrimSpace(cfg.Form.Name)
+		cfg.OutputPath = strings.TrimSpace(cfg.OutputPath)
+		cfg.DatabaseFlagSet = cmd.Flags().Changed("database")
+		cfg.MakefileFlagSet = cmd.Flags().Changed("makefile")
+		cfg.DockerFlagSet = cmd.Flags().Changed("docker")
+		return nil
 	}
 }

cmd/version.go

@@ -17,6 +17,6 @@ Cobra is a CLI library for Go that empowers applications.
 This application is a tool to generate the needed files
 to quickly create a Cobra application.`,
 	Run: func(cmd *cobra.Command, args []string) {
-		fmt.Println("v0.2.0")
+		fmt.Println("v0.3.0")
 	},
 }

internal/config/config.go

@@ -10,9 +10,13 @@ const (
 )
 
 type Config struct {
-	OutputPath string
-	Default    bool
-	Form       Form
+	OutputPath      string
+	Default         bool
+	Force           bool
+	DatabaseFlagSet bool
+	MakefileFlagSet bool
+	DockerFlagSet   bool
+	Form            Form
 }
 
 type Form struct {

internal/goforge/forge.go

@@ -5,10 +5,15 @@ import (
 
 	"github.com/andrearcaina/goforge/internal/config"
 	"github.com/andrearcaina/goforge/internal/ui"
+	"github.com/andrearcaina/goforge/internal/utils"
 	"github.com/charmbracelet/huh/spinner"
 )
 
 func Forge(cfg *config.Config) error {
+	if cfg == nil {
+		return fmt.Errorf("invalid configuration: configuration cannot be nil")
+	}
+
 	if cfg.Default {
 		cfg.Form = config.Form{
 			Name:           "example-server",
@@ -21,6 +26,10 @@ func Forge(cfg *config.Config) error {
 		}
 	}
 
+	if err := utils.Validate(cfg); err != nil {
+		return fmt.Errorf("invalid configuration: %w", err)
+	}
+
 	var err error
 	_ = spinner.New().
 		Title("Forging your project...").

internal/goforge/generator.go

@@ -2,16 +2,61 @@ package goforge
 
 import (
 	"fmt"
+	"io/fs"
 	"os"
 	"path/filepath"
 	"text/template"
 	"time"
 
 	"github.com/andrearcaina/goforge/internal/config"
 	"github.com/andrearcaina/goforge/internal/templates"
+	"github.com/andrearcaina/goforge/internal/utils"
 )
 
 func Generate(cfg *config.Config) error {
+	if err := utils.Validate(cfg); err != nil {
+		return fmt.Errorf("invalid configuration: %w", err)
+	}
+
+	outputPath := filepath.Clean(cfg.OutputPath)
+	parentPath := filepath.Dir(outputPath)
+	if err := os.MkdirAll(parentPath, 0755); err != nil {
+		return fmt.Errorf("create output parent directory: %w", err)
+	}
+
+	if info, err := os.Lstat(outputPath); err == nil {
+		if info.Mode()&os.ModeSymlink != 0 {
+			return fmt.Errorf("output path %q must not be a symbolic link", outputPath)
+		}
+		if !info.IsDir() {
+			return fmt.Errorf("output path %q is not a directory", outputPath)
+		}
+	} else if !os.IsNotExist(err) {
+		return fmt.Errorf("inspect output path: %w", err)
+	}
+
+	stagingPath, err := os.MkdirTemp(parentPath, ".goforge-stage-*")
+	if err != nil {
+		return fmt.Errorf("create staging directory: %w", err)
+	}
+	defer func() {
+		_ = os.RemoveAll(stagingPath)
+	}()
+
+	stagingCfg := *cfg
+	stagingCfg.OutputPath = stagingPath
+	if err := generateProject(&stagingCfg); err != nil {
+		return fmt.Errorf("render project: %w", err)
+	}
+
+	if err := commitGeneratedProject(stagingPath, outputPath, cfg.Force); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func generateProject(cfg *config.Config) error {
 	if err := generateBaseFiles(cfg); err != nil {
 		return err
 	}
@@ -75,6 +120,90 @@ func Generate(cfg *config.Config) error {
 	return nil
 }
 
+func commitGeneratedProject(stagingPath, outputPath string, force bool) error {
+	if _, err := os.Lstat(outputPath); os.IsNotExist(err) {
+		if err := os.Rename(stagingPath, outputPath); err != nil {
+			return fmt.Errorf("commit generated project: %w", err)
+		}
+		return nil
+	} else if err != nil {
+		return fmt.Errorf("inspect output path: %w", err)
+	}
+
+	var dirs []string
+	var files []string
+	err := filepath.WalkDir(stagingPath, func(path string, entry fs.DirEntry, walkErr error) error {
+		if walkErr != nil {
+			return walkErr
+		}
+		if path == stagingPath {
+			return nil
+		}
+
+		relativePath, err := filepath.Rel(stagingPath, path)
+		if err != nil {
+			return err
+		}
+		if entry.IsDir() {
+			dirs = append(dirs, relativePath)
+		} else {
+			files = append(files, relativePath)
+		}
+		return nil
+	})
+	if err != nil {
+		return fmt.Errorf("inspect staged project: %w", err)
+	}
+
+	for _, relativePath := range dirs {
+		targetPath := filepath.Join(outputPath, relativePath)
+		if info, err := os.Lstat(targetPath); err == nil && !info.IsDir() {
+			return fmt.Errorf("cannot create directory %q because a file already exists there", targetPath)
+		} else if err != nil && !os.IsNotExist(err) {
+			return fmt.Errorf("inspect destination %q: %w", targetPath, err)
+		}
+	}
+
+	for _, relativePath := range files {
+		targetPath := filepath.Join(outputPath, relativePath)
+		if info, err := os.Lstat(targetPath); err == nil {
+			if info.IsDir() {
+				return fmt.Errorf("cannot generate file %q because a directory already exists there", targetPath)
+			}
+			if !force {
+				return fmt.Errorf("refusing to overwrite existing file %q; use --force to overwrite generated files", targetPath)
+			}
+		} else if !os.IsNotExist(err) {
+			return fmt.Errorf("inspect destination %q: %w", targetPath, err)
+		}
+	}
+
+	for _, relativePath := range dirs {
+		targetPath := filepath.Join(outputPath, relativePath)
+		if err := os.MkdirAll(targetPath, 0755); err != nil {
+			return fmt.Errorf("create destination directory %q: %w", targetPath, err)
+		}
+	}
+
+	for _, relativePath := range files {
+		sourcePath := filepath.Join(stagingPath, relativePath)
+		targetPath := filepath.Join(outputPath, relativePath)
+		if err := os.MkdirAll(filepath.Dir(targetPath), 0755); err != nil {
+			return fmt.Errorf("create destination directory for %q: %w", targetPath, err)
+		}
+		if force {
+			if err := os.Remove(targetPath); err != nil && !os.IsNotExist(err) {
+				return fmt.Errorf("replace existing file %q: %w", targetPath, err)
+			}
+		}
+		if err := os.Rename(sourcePath, targetPath); err != nil {
+			return fmt.Errorf("commit generated file %q: %w", targetPath, err)
+		}
+	}
+
+	return nil
+}
+
 func generateDirs(cfg *config.Config, dirs []string) error {
 	for _, dir := range dirs {
 		if err := os.MkdirAll(filepath.Join(cfg.OutputPath, dir), 0755); err != nil {
@@ -153,11 +282,11 @@ func generateSpecificFile(tmplPath []string, outputPath string, data interface{}
 	if err != nil {
 		return err
 	}
-	defer out.Close()
 
 	if err := tmpl.Execute(out, data); err != nil {
+		_ = out.Close()
 		return err
 	}
 
-	return nil
+	return out.Close()
 }