Vite + React
28 |
29 |
32 |
36 |
33 | Edit src/App.tsx and save to test HMR
34 |
37 | Click on the Vite and React logos to learn more 38 |
39 | 42 | {message && ( 43 |
44 |
47 | )}
48 |
49 | )
50 | }
51 |
52 | export default App
53 |
--------------------------------------------------------------------------------
/.github/ISSUE_TEMPLATE/bug-report.yml:
--------------------------------------------------------------------------------
1 | name: Bug Report
2 | description: Found a bug? Please let us know!
3 | title: "[Bug]"
4 | labels: ["Bug"]
5 | body:
6 | - type: markdown
7 | attributes:
8 | value: |
9 | Please provide as much information as possible. This will help us resolve the Bug quickly and accurately.
10 | - type: markdown
11 | attributes:
12 | value: ---
13 | - type: textarea
14 | id: what-happened
15 | attributes:
16 | label: What is the problem?
17 | description: |
18 | Description of what needs to be fixed.
19 | placeholder: Tell us what you see!
20 | validations:
21 | required: true
22 | - type: input
23 | id: os
24 | attributes:
25 | label: Operating System
26 | description: What is the affected operating system?
27 | validations:
28 | required: true
29 | - type: input
30 | id: arch
31 | attributes:
32 | label: Architecture Version (x86, x64, arm, etc)
33 | description: (x86, x64, arm, etc)
34 | validations:
35 | required: true
36 | - type: textarea
37 | id: reproduce
38 | attributes:
39 | label: Steps to reproduce
40 | description: |
41 | This includes the steps for reproducing the problem, the expected result, and the actual result.
42 | placeholder: |
43 | 1. ...
44 | 2. ...
45 | 3. ...
46 | validations:
47 | required: true
48 | - type: textarea
49 | id: logs
50 | attributes:
51 | label: Relevant log output
52 | description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
53 | render: shell
54 |
--------------------------------------------------------------------------------
/cmd/template/framework/files/main/main.go.tmpl:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "log"
7 | "net/http"
8 | "os/signal"
9 | "syscall"
10 | "time"
11 |
12 | "{{.ProjectName}}/internal/server"
13 | )
14 |
15 | func gracefulShutdown(apiServer *http.Server, done chan bool) {
16 | // Create context that listens for the interrupt signal from the OS.
17 | ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
18 | defer stop()
19 |
20 | // Listen for the interrupt signal.
21 | <-ctx.Done()
22 |
23 | log.Println("shutting down gracefully, press Ctrl+C again to force")
24 | stop() // Allow Ctrl+C to force shutdown
25 |
26 | // The context is used to inform the server it has 5 seconds to finish
27 | // the request it is currently handling
28 | ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
29 | defer cancel()
30 | if err := apiServer.Shutdown(ctx); err != nil {
31 | log.Printf("Server forced to shutdown with error: %v", err)
32 | }
33 |
34 | log.Println("Server exiting")
35 |
36 | // Notify the main goroutine that the shutdown is complete
37 | done <- true
38 | }
39 |
40 | func main() {
41 |
42 | server := server.NewServer()
43 |
44 | // Create a done channel to signal when the shutdown is complete
45 | done := make(chan bool, 1)
46 |
47 | // Run graceful shutdown in a separate goroutine
48 | go gracefulShutdown(server, done)
49 |
50 | err := server.ListenAndServe()
51 | if err != nil && err != http.ErrServerClosed {
52 | panic(fmt.Sprintf("http server error: %s", err))
53 | }
54 |
55 | // Wait for the graceful shutdown to complete
56 | <-done
57 | log.Println("Graceful shutdown complete.")
58 | }
59 |
--------------------------------------------------------------------------------
/docs/docs/advanced-flag/advanced-flag.md:
--------------------------------------------------------------------------------
1 | # Advanced Flag in Blueprint
2 |
3 | The `--advanced` flag in Blueprint serves as a switch to enable additional features during project creation. It is applied with the `create` command and unlocks the following features:
4 |
5 | - **HTMX Support using Templ:**
6 | Enables the integration of HTMX support for dynamic web pages using Templ.
7 |
8 | - **CI/CD Workflow Setup using GitHub Actions:**
9 | Automates the setup of a CI/CD workflow using GitHub Actions.
10 |
11 | - **Websocket Support:**
12 | WebSocket endpoint that sends continuous data streams through the WS protocol.
13 |
14 | - **Tailwind:**
15 | Adds Tailwind CSS support to the project.
16 |
17 | - **Docker:**
18 | Docker configuration for go project.
19 |
20 | - **React:**
21 | Frontend written in TypeScript, including an example fetch request to the backend.
22 |
23 |
24 | To utilize the `--advanced` flag, use the following command:
25 |
26 | ```bash
27 | go-blueprint create --name Server Response:
45 |{message}
46 |
16 |
56 | )
57 | }
58 |
59 | export default App
--------------------------------------------------------------------------------
/docs/docs/creating-project/makefile.md:
--------------------------------------------------------------------------------
1 | ## Makefile Project Management
2 |
3 | Makefile is designed for building, running, and testing a Go project. It includes support for advanced options like HTMX and Tailwind CSS, and handles OS-specific operations for Unix-based systems (Linux/macOS) and Windows.
4 |
5 | ## Targets
6 |
7 | ***`all`***
8 |
9 | The default target that builds and test the application by running the `build` and `test` target.
10 |
11 | ***`templ-install`***
12 |
13 | This target installs the Go-based templating tool, `templ`, if it is not already installed. It supports:
14 |
15 | - **Unix-based systems**: Prompts the user to install `templ` if it is missing.
16 | - **Windows**: Uses PowerShell to check for and install `templ`.
17 |
18 | ***`tailwind-install`***
19 |
20 | This target downloads and sets up `tailwindcss`, depending on the user's operating system:
21 |
22 | - **Linux**: Downloads the Linux binary.
23 | - **macOS**: Downloads the macOS binary.
24 | - **Windows**: Uses PowerShell to download the Windows executable.
25 |
26 | ***`build`***
27 |
28 | Builds the Go application and generates assets with `templ` and `tailwind`, if the corresponding advanced options are enabled:
29 |
30 | - Uses `templ` to generate templates.
31 | - Runs `tailwindcss` to compile CSS.
32 |
33 | ***`run`***
34 |
35 | Runs the Go application by executing the `cmd/api/main.go` file and npm install with run dev if React flag is used.
36 |
37 | ***`docker-run`*** and ***`docker-down`***
38 |
39 | These targets manage a database container:
40 |
41 | - **Unix-based systems**: Tries Docker Compose V2 first, falls back to V1 if needed.
42 | - **Windows**: Uses Docker Compose without version fallback.
43 |
44 | ***`test`***
45 |
46 | Runs unit tests for the application using `go test`.
47 |
48 | ***`itest`***
49 |
50 | Runs integration tests if a database, with the exception of SQLite, is used.
51 |
52 | ***`clean`***
53 |
54 | Removes the compiled binary (`main` or `main.exe` depending on the OS).
55 |
56 | ***`watch`***
57 |
58 | Enables live reload for the project using the `air` tool:
59 |
60 | - **Unix-based systems**: Checks if `air` is installed and prompts for installation if missing.
61 | - **Windows**: Uses PowerShell to manage `air` installation and execution.
62 |
63 |
--------------------------------------------------------------------------------
/cmd/template/framework/files/routes/echo.go.tmpl:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "net/http"
5 | {{if .AdvancedOptions.websocket}}
6 | "log"
7 | "fmt"
8 | "time"
9 | {{end}}
10 |
11 | "github.com/labstack/echo/v4"
12 | "github.com/labstack/echo/v4/middleware"
13 | {{.AdvancedTemplates.TemplateImports}}
14 | )
15 | func (s *Server) RegisterRoutes() http.Handler {
16 | e := echo.New()
17 | e.Use(middleware.Logger())
18 | e.Use(middleware.Recover())
19 |
20 | e.Use(middleware.CORSWithConfig(middleware.CORSConfig{
21 | AllowOrigins: []string{"https://*", "http://*"},
22 | AllowMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"},
23 | AllowHeaders: []string{"Accept", "Authorization", "Content-Type", "X-CSRF-Token"},
24 | AllowCredentials: true,
25 | MaxAge: 300,
26 | }))
27 |
28 | {{.AdvancedTemplates.TemplateRoutes}}
29 |
30 | e.GET("/", s.HelloWorldHandler)
31 | {{if ne .DBDriver "none"}}
32 | e.GET("/health", s.healthHandler)
33 | {{end}}
34 | {{if .AdvancedOptions.websocket}}
35 | e.GET("/websocket", s.websocketHandler)
36 | {{end}}
37 |
38 | return e
39 | }
40 |
41 | func (s *Server) HelloWorldHandler(c echo.Context) error {
42 | resp := map[string]string{
43 | "message": "Hello World",
44 | }
45 |
46 | return c.JSON(http.StatusOK, resp)
47 | }
48 |
49 | {{if ne .DBDriver "none"}}
50 | func (s *Server) healthHandler(c echo.Context) error {
51 | return c.JSON(http.StatusOK, s.db.Health())
52 | }
53 | {{end}}
54 |
55 | {{if .AdvancedOptions.websocket}}
56 | func (s *Server) websocketHandler(c echo.Context) error {
57 | w := c.Response().Writer
58 | r := c.Request()
59 | socket, err := websocket.Accept(w, r, nil)
60 |
61 | if err != nil {
62 | log.Printf("could not open websocket: %v", err)
63 | _, _ = w.Write([]byte("could not open websocket"))
64 | w.WriteHeader(http.StatusInternalServerError)
65 | return nil
66 | }
67 |
68 | defer socket.Close(websocket.StatusGoingAway, "server closing websocket")
69 |
70 | ctx := r.Context()
71 | socketCtx := socket.CloseRead(ctx)
72 |
73 | for {
74 | payload := fmt.Sprintf("server timestamp: %d", time.Now().UnixNano())
75 | err := socket.Write(socketCtx, websocket.MessageText, []byte(payload))
76 | if err != nil {
77 | break
78 | }
79 | time.Sleep(time.Second * 2)
80 | }
81 | return nil
82 | }
83 | {{end}}
84 |
85 |
--------------------------------------------------------------------------------
/cmd/template/dbdriver/files/tests/mysql.tmpl:
--------------------------------------------------------------------------------
1 | package database
2 |
3 | import (
4 | "context"
5 | "log"
6 | "testing"
7 | "time"
8 |
9 | "github.com/testcontainers/testcontainers-go"
10 | "github.com/testcontainers/testcontainers-go/modules/mysql"
11 | "github.com/testcontainers/testcontainers-go/wait"
12 | )
13 |
14 | func mustStartMySQLContainer() (func(context.Context, ...testcontainers.TerminateOption) error, error) {
15 | var (
16 | dbName = "database"
17 | dbPwd = "password"
18 | dbUser = "user"
19 | )
20 |
21 | dbContainer, err := mysql.Run(context.Background(),
22 | "mysql:8.0.36",
23 | mysql.WithDatabase(dbName),
24 | mysql.WithUsername(dbUser),
25 | mysql.WithPassword(dbPwd),
26 | testcontainers.WithWaitStrategy(wait.ForLog("port: 3306 MySQL Community Server - GPL").WithStartupTimeout(30*time.Second)),
27 | )
28 | if err != nil {
29 | return nil, err
30 | }
31 |
32 | dbname = dbName
33 | password = dbPwd
34 | username = dbUser
35 |
36 | dbHost, err := dbContainer.Host(context.Background())
37 | if err != nil {
38 | return dbContainer.Terminate, err
39 | }
40 |
41 | dbPort, err := dbContainer.MappedPort(context.Background(), "3306/tcp")
42 | if err != nil {
43 | return dbContainer.Terminate, err
44 | }
45 |
46 | host = dbHost
47 | port = dbPort.Port()
48 |
49 | return dbContainer.Terminate, err
50 | }
51 |
52 | func TestMain(m *testing.M) {
53 | teardown, err := mustStartMySQLContainer()
54 | if err != nil {
55 | log.Fatalf("could not start mysql container: %v", err)
56 | }
57 |
58 | m.Run()
59 |
60 | if teardown != nil && teardown(context.Background()) != nil {
61 | log.Fatalf("could not teardown mysql container: %v", err)
62 | }
63 | }
64 |
65 | func TestNew(t *testing.T) {
66 | srv := New()
67 | if srv == nil {
68 | t.Fatal("New() returned nil")
69 | }
70 | }
71 |
72 | func TestHealth(t *testing.T) {
73 | srv := New()
74 |
75 | stats := srv.Health()
76 |
77 | if stats["status"] != "up" {
78 | t.Fatalf("expected status to be up, got %s", stats["status"])
79 | }
80 |
81 | if _, ok := stats["error"]; ok {
82 | t.Fatalf("expected error not to be present")
83 | }
84 |
85 | if stats["message"] != "It's healthy" {
86 | t.Fatalf("expected message to be 'It's healthy', got %s", stats["message"])
87 | }
88 | }
89 |
90 | func TestClose(t *testing.T) {
91 | srv := New()
92 |
93 | if srv.Close() != nil {
94 | t.Fatalf("expected Close() to return nil")
95 | }
96 | }
97 |
--------------------------------------------------------------------------------
/cmd/template/framework/files/routes/chi.go.tmpl:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "encoding/json"
5 | "log"
6 | "net/http"
7 | {{if .AdvancedOptions.websocket}}
8 | "fmt"
9 | "time"
10 | {{end}}
11 |
12 | "github.com/go-chi/chi/v5"
13 | "github.com/go-chi/chi/v5/middleware"
14 | "github.com/go-chi/cors"
15 | {{.AdvancedTemplates.TemplateImports}}
16 |
17 | )
18 |
19 | func (s *Server) RegisterRoutes() http.Handler {
20 | r := chi.NewRouter()
21 | r.Use(middleware.Logger)
22 |
23 | r.Use(cors.Handler(cors.Options{
24 | AllowedOrigins: []string{"https://*", "http://*"},
25 | AllowedMethods: []string{"GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"},
26 | AllowedHeaders: []string{"Accept", "Authorization", "Content-Type"},
27 | AllowCredentials: true,
28 | MaxAge: 300,
29 | }))
30 |
31 | r.Get("/", s.HelloWorldHandler)
32 | {{if ne .DBDriver "none"}}
33 | r.Get("/health", s.healthHandler)
34 | {{end}}
35 | {{if .AdvancedOptions.websocket}}
36 | r.Get("/websocket", s.websocketHandler)
37 | {{end}}
38 | {{.AdvancedTemplates.TemplateRoutes}}
39 |
40 | return r
41 | }
42 |
43 | func (s *Server) HelloWorldHandler(w http.ResponseWriter, r *http.Request) {
44 | resp := make(map[string]string)
45 | resp["message"] = "Hello World"
46 |
47 | jsonResp, err := json.Marshal(resp)
48 | if err != nil {
49 | log.Fatalf("error handling JSON marshal. Err: %v", err)
50 | }
51 |
52 | _, _ = w.Write(jsonResp)
53 | }
54 |
55 | {{if ne .DBDriver "none"}}
56 | func (s *Server) healthHandler(w http.ResponseWriter, r *http.Request) {
57 | jsonResp, _ := json.Marshal(s.db.Health())
58 | _, _ = w.Write(jsonResp)
59 | }
60 | {{end}}
61 |
62 | {{if .AdvancedOptions.websocket}}
63 | func (s *Server) websocketHandler(w http.ResponseWriter, r *http.Request) {
64 | socket, err := websocket.Accept(w, r, nil)
65 |
66 | if err != nil {
67 | log.Printf("could not open websocket: %v", err)
68 | _, _ = w.Write([]byte("could not open websocket"))
69 | w.WriteHeader(http.StatusInternalServerError)
70 | return
71 | }
72 |
73 | defer socket.Close(websocket.StatusGoingAway, "server closing websocket")
74 |
75 | ctx := r.Context()
76 | socketCtx := socket.CloseRead(ctx)
77 |
78 | for {
79 | payload := fmt.Sprintf("server timestamp: %d", time.Now().UnixNano())
80 | err := socket.Write(socketCtx, websocket.MessageText, []byte(payload))
81 | if err != nil {
82 | break
83 | }
84 | time.Sleep(time.Second * 2)
85 | }
86 | }
87 | {{end}}
88 |
89 |
--------------------------------------------------------------------------------
/docs/docs/advanced-flag/htmx-templ.md:
--------------------------------------------------------------------------------
1 | The WEB directory contains the web-related components and assets for the project. It leverages [htmx](https://github.com/bigskysoftware/htmx) and [templ](https://github.com/a-h/templ) in Go for dynamic web content generation.
2 |
3 | ## Structure
4 |
5 | ```
6 | web/
7 | │
8 | │
9 | ├── assets/
10 | │ └── js/
11 | │ └── htmx.min.js # htmx library for dynamic HTML content
12 | │
13 | ├── base.templ # Base template for HTML structure
14 | ├── base_templ.go # Generated Go code for base template
15 | ├── efs.go # Embeds static files into the Go binary
16 | │
17 | ├── hello.go # Handler for the Hello Web functionality
18 | ├── hello.templ # Template for rendering the Hello form and post data
19 | └── hello_templ.go # Generated Go code for hello template
20 | ```
21 |
22 | ## Usage
23 |
24 | - **Navigate to Project Directory:**
25 | ```bash
26 | cd my-project
27 | ```
28 |
29 | - **Install Templ CLI:**
30 | ```bash
31 | go install github.com/a-h/templ/cmd/templ@latest
32 | ```
33 |
34 | - **Generate Templ Function Files:**
35 | ```bash
36 | templ generate
37 | ```
38 |
39 | - **Start Server:**
40 | ```bash
41 | make run
42 | ```
43 |
44 | ## Makefile
45 |
46 | Automates templ with Makefile entries, which are automatically created if the htmx advanced flag is used.
47 | It detects if templ is installed or not and generates templates with the make build command.
48 | Both Windows and Unix-like OS are supported.
49 |
50 | ```bash
51 | all: build
52 |
53 | templ-install:
54 | @if ! command -v templ > /dev/null; then \
55 | read -p "Go's 'templ' is not installed on your machine. Do you want to install it? [Y/n] " choice; \
56 | if [ "$$choice" != "n" ] && [ "$$choice" != "N" ]; then \
57 | go install github.com/a-h/templ/cmd/templ@latest; \
58 | if [ ! -x "$$(command -v templ)" ]; then \
59 | echo "templ installation failed. Exiting..."; \
60 | exit 1; \
61 | fi; \
62 | else \
63 | echo "You chose not to install templ. Exiting..."; \
64 | exit 1; \
65 | fi; \
66 | fi
67 |
68 | build: templ-install
69 | @echo "Building..."
70 | @templ generate
71 | @go build -o main cmd/api/main.go
72 | ```
73 |
74 | ## Templating
75 |
76 | Templates are generated using the `templ generate` command after project creation. These templates are then compiled into Go code for efficient execution.
77 |
78 | You can test HTMX functionality on `localhost:PORT/web` endpoint.
79 |
--------------------------------------------------------------------------------
/docs/mkdocs.yml:
--------------------------------------------------------------------------------
1 | ### Site metadata ###
2 |
3 | site_name: Go-Blueprint Docs
4 | site_description: Official documentation for Go-Blueprint project
5 | site_url: https://docs.go-blueprint.dev/
6 |
7 | repo_url: https://github.com/Melkeydev/go-blueprint
8 | edit_uri: edit/main/docs/docs
9 |
10 | ### Build settings ###
11 |
12 | theme:
13 | name: material
14 | custom_dir: custom_theme/
15 | theme:
16 | features:
17 | - navigation.instant
18 | - navigation.sections
19 | - navigation.footer
20 | - toc.flow
21 | palette:
22 | - scheme: default
23 | toggle:
24 | icon: material/brightness-7
25 | name: Switch to dark mode
26 | - scheme: slate
27 | toggle:
28 | icon: material/brightness-4
29 | name: Switch to light mode
30 |
31 | nav:
32 | - Home: index.md
33 | - Installation: installation.md
34 | - Blueprint UI: blueprint-ui.md
35 | - Project creation & default config:
36 | - Project init: creating-project/project-init.md
37 | - Makefile: creating-project/makefile.md
38 | - Air: creating-project/air.md
39 | - Blueprint Core:
40 | - Frameworks: blueprint-core/frameworks.md
41 | - DB Drivers: blueprint-core/db-drivers.md
42 | - Advanced Flag:
43 | - AF Usage: advanced-flag/advanced-flag.md
44 | - HTMX and Templ: advanced-flag/htmx-templ.md
45 | - Tailwind CSS: advanced-flag/tailwind.md
46 | - GoReleaser & GoTest CI: advanced-flag/goreleaser.md
47 | - Websocket: advanced-flag/websocket.md
48 | - Docker: advanced-flag/docker.md
49 | - React & Vite (TypeScript): advanced-flag/react-vite.md
50 | - Testing endpoints:
51 | - Server: endpoints-test/server.md
52 | - DB Health Endpoints:
53 | - SQL DBs: endpoints-test/sql.md
54 | - Redis: endpoints-test/redis.md
55 | - MongoDB: endpoints-test/mongo.md
56 | - ScyllaDB: endpoints-test/scylladb.md
57 | - Websocket: endpoints-test/websocket.md
58 | - Web Endpoint: endpoints-test/web.md
59 |
60 | extra:
61 | social:
62 | - icon: fontawesome/brands/discord
63 | link: https://discord.com/invite/HHZMSCu
64 | name: Discord
65 | - icon: fontawesome/brands/twitch
66 | link: https://www.twitch.tv/melkey
67 | name: Twitch
68 | - icon: fontawesome/brands/youtube
69 | link: https://www.youtube.com/@MelkeyDev
70 | name: YouTube
71 | - icon: fontawesome/brands/twitter
72 | link: https://x.com/MelkeyDev
73 | name: Twitter
74 | generator: false
75 |
76 | copyright: Copyright © 2025 Melkey
77 |
--------------------------------------------------------------------------------
/cmd/version.go:
--------------------------------------------------------------------------------
1 | /*
2 | Go blueprint version
3 | */
4 | package cmd
5 |
6 | import (
7 | "fmt"
8 | "runtime/debug"
9 | "time"
10 |
11 | "github.com/spf13/cobra"
12 | )
13 |
14 | // GoBlueprintVersion is the version of the cli to be overwritten by goreleaser in the CI run with the version of the release in github
15 | var GoBlueprintVersion string
16 |
17 | // Go Blueprint needs to be built in a specific way to provide useful version information.
18 | // First we try to get the version from ldflags embedded into GoBlueprintVersion.
19 | // Then we try to get the version from from the go.mod build info.
20 | // If Go Blueprint is installed with a specific version tag or using @latest then that version will be included in bi.Main.Version.
21 | // This won't give any version info when running 'go install' with the source code locally.
22 | // Finally we try to get the version from other embedded VCS info.
23 | func getGoBlueprintVersion() string {
24 | noVersionAvailable := "No version info available for this build, run 'go-blueprint help version' for additional info"
25 |
26 | if len(GoBlueprintVersion) != 0 {
27 | return GoBlueprintVersion
28 | }
29 |
30 | bi, ok := debug.ReadBuildInfo()
31 | if !ok {
32 | return noVersionAvailable
33 | }
34 |
35 | // If no main version is available, Go defaults it to (devel)
36 | if bi.Main.Version != "(devel)" {
37 | return bi.Main.Version
38 | }
39 |
40 | var vcsRevision string
41 | var vcsTime time.Time
42 | for _, setting := range bi.Settings {
43 | switch setting.Key {
44 | case "vcs.revision":
45 | vcsRevision = setting.Value
46 | case "vcs.time":
47 | vcsTime, _ = time.Parse(time.RFC3339, setting.Value)
48 | }
49 | }
50 |
51 | if vcsRevision != "" {
52 | return fmt.Sprintf("%s, (%s)", vcsRevision, vcsTime)
53 | }
54 |
55 | return noVersionAvailable
56 | }
57 |
58 | // versionCmd represents the version command
59 | var versionCmd = &cobra.Command{
60 | Use: "version",
61 | Short: "Display application version information.",
62 | Long: `
63 | The version command provides information about the application's version.
64 |
65 | Go Blueprint requires version information to be embedded at compile time.
66 | For detailed version information, Go Blueprint needs to be built as specified in the README installation instructions.
67 | If Go Blueprint is built within a version control repository and other version info isn't available,
68 | the revision hash will be used instead.
69 | `,
70 | Run: func(cmd *cobra.Command, args []string) {
71 | version := getGoBlueprintVersion()
72 | fmt.Printf("Go Blueprint CLI version: %v\n", version)
73 | },
74 | }
75 |
--------------------------------------------------------------------------------
/docs/docs/creating-project/air.md:
--------------------------------------------------------------------------------
1 | ## Air - Live Reloading Utility
2 |
3 | [Air](https://github.com/cosmtrek/air) is a live-reloading utility designed to enhance the development experience by automatically rebuilding and restarting your Go application whenever changes are detected in the source code.
4 |
5 | The Makefile provided in the project repository includes a command make watch, which triggers Air to monitor file changes and initiate rebuilds and restarts as necessary. Additionally, if Air is not installed on your machine, the Makefile provides an option to install it automatically.
6 |
7 | Air's `.air.toml` configuration file allows customization of various aspects of its behavior.
8 |
9 | ## Live Preview
10 |
11 | ```bash
12 | make watch
13 |
14 | __ _ ___
15 | / /\ | | | |_)
16 | /_/--\ |_| |_| \_ v1.51.0, built with Go go1.22.0
17 |
18 | mkdir /home/ujstor/code/blueprint-version-test/ws-test4/tmp
19 | watching .
20 | watching cmd
21 | watching cmd/api
22 | watching cmd/web
23 | watching cmd/web/assets
24 | watching cmd/web/assets/js
25 | watching internal
26 | watching internal/database
27 | watching internal/server
28 | watching tests
29 | !exclude tmp
30 | building...
31 | make[1]: Entering directory '/home/ujstor/code/blueprint-version-test/ws-test4'
32 | Building...
33 | Processing path: /home/ujstor/code/blueprint-version-test/ws-test4
34 | Generated code for "/home/ujstor/code/blueprint-version-test/ws-test4/cmd/web/base.templ" in 914.556µs
35 | Generated code for "/home/ujstor/code/blueprint-version-test/ws-test4/cmd/web/hello.templ" in 963.157µs
36 | Generated code for 2 templates with 0 errors in 1.274392ms
37 | make[1]: Leaving directory '/home/ujstor/code/blueprint-version-test/ws-test4'
38 | running...
39 | internal/server/routes.go has changed
40 | building...
41 | make[1]: Entering directory '/home/ujstor/code/blueprint-version-test/ws-test4'
42 | Building...
43 | Processing path: /home/ujstor/code/blueprint-version-test/ws-test4
44 | Generated code for "/home/ujstor/code/blueprint-version-test/ws-test4/cmd/web/base.templ" in 907.426µs
45 | Generated code for "/home/ujstor/code/blueprint-version-test/ws-test4/cmd/web/hello.templ" in 1.16142ms
46 | Generated code for 2 templates with 0 errors in 1.527556ms
47 | make[1]: Leaving directory '/home/ujstor/code/blueprint-version-test/ws-test4'
48 | running...
49 | ```
50 |
51 | Integrating Air into your development workflow alongside the provided Makefile enables a smooth and efficient process for building, testing, and running your Go applications. With automatic live-reloading, you can focus more on coding and less on manual build and restart steps.
52 |
--------------------------------------------------------------------------------
/cmd/template/dbdriver/files/tests/postgres.tmpl:
--------------------------------------------------------------------------------
1 | package database
2 |
3 | import (
4 | "context"
5 | "log"
6 | "testing"
7 | "time"
8 |
9 | "github.com/testcontainers/testcontainers-go"
10 | "github.com/testcontainers/testcontainers-go/modules/postgres"
11 | "github.com/testcontainers/testcontainers-go/wait"
12 | )
13 |
14 | func mustStartPostgresContainer() (func(context.Context, ...testcontainers.TerminateOption) error, error) {
15 | var (
16 | dbName = "database"
17 | dbPwd = "password"
18 | dbUser = "user"
19 | )
20 |
21 | dbContainer, err := postgres.Run(
22 | context.Background(),
23 | "postgres:latest",
24 | postgres.WithDatabase(dbName),
25 | postgres.WithUsername(dbUser),
26 | postgres.WithPassword(dbPwd),
27 | testcontainers.WithWaitStrategy(
28 | wait.ForLog("database system is ready to accept connections").
29 | WithOccurrence(2).
30 | WithStartupTimeout(5*time.Second)),
31 | )
32 | if err != nil {
33 | return nil, err
34 | }
35 |
36 | database = dbName
37 | password = dbPwd
38 | username = dbUser
39 |
40 | dbHost, err := dbContainer.Host(context.Background())
41 | if err != nil {
42 | return dbContainer.Terminate, err
43 | }
44 |
45 | dbPort, err := dbContainer.MappedPort(context.Background(), "5432/tcp")
46 | if err != nil {
47 | return dbContainer.Terminate, err
48 | }
49 |
50 | host = dbHost
51 | port = dbPort.Port()
52 |
53 | return dbContainer.Terminate, err
54 | }
55 |
56 | func TestMain(m *testing.M) {
57 | teardown, err := mustStartPostgresContainer()
58 | if err != nil {
59 | log.Fatalf("could not start postgres container: %v", err)
60 | }
61 |
62 | m.Run()
63 |
64 | if teardown != nil && teardown(context.Background()) != nil {
65 | log.Fatalf("could not teardown postgres container: %v", err)
66 | }
67 | }
68 |
69 | func TestNew(t *testing.T) {
70 | srv := New()
71 | if srv == nil {
72 | t.Fatal("New() returned nil")
73 | }
74 | }
75 |
76 | func TestHealth(t *testing.T) {
77 | srv := New()
78 |
79 | stats := srv.Health()
80 |
81 | if stats["status"] != "up" {
82 | t.Fatalf("expected status to be up, got %s", stats["status"])
83 | }
84 |
85 | if _, ok := stats["error"]; ok {
86 | t.Fatalf("expected error not to be present")
87 | }
88 |
89 | if stats["message"] != "It's healthy" {
90 | t.Fatalf("expected message to be 'It's healthy', got %s", stats["message"])
91 | }
92 | }
93 |
94 | func TestClose(t *testing.T) {
95 | srv := New()
96 |
97 | if srv.Close() != nil {
98 | t.Fatalf("expected Close() to return nil")
99 | }
100 | }
101 |
--------------------------------------------------------------------------------
/docs/docs/advanced-flag/tailwind.md:
--------------------------------------------------------------------------------
1 | Tailwind is closely coupled with the advanced HTMX flag, and HTMX will be automatically used if you select Tailwind in your project.
2 |
3 | We do not introduce outside dependencies automatically, and you need compile output.css (file is empty by default) with the Tailwind CLI tool.
4 |
5 | The project tree would look like this:
6 |
7 | ```bash
8 | / (Root)
9 | ├── cmd/
10 | │ ├── api/
11 | │ │ └── main.go
12 | │ └── web/
13 | │ ├── styles/
14 | │ │ └── input.css
15 | │ ├── assets/
16 | │ │ ├── css/
17 | │ │ │ └── output.css
18 | │ │ └── js/
19 | │ │ └── htmx.min.js
20 | │ ├── base.templ
21 | │ ├── base_templ.go
22 | │ ├── efs.go
23 | │ ├── hello.go
24 | │ ├── hello.templ
25 | │ └── hello_templ.go
26 | ├── internal/
27 | │ └── server/
28 | │ ├── routes.go
29 | │ ├── routes_test.go
30 | │ └── server.go
31 | ├── go.mod
32 | ├── go.sum
33 | ├── Makefile
34 | └── README.md
35 | ```
36 |
37 | ## Standalone Tailwind CLI
38 |
39 | The idea is to avoid using Node.js and npm to build output.css.
40 |
41 | The Makefile will have entries for downloading and compiling CSS. It will automatically detect the OS and download the latest release from the [official repository](https://github.com/tailwindlabs/tailwindcss/releases).
42 |
43 | ## Linux Makefile Example
44 |
45 | ```bash
46 | all: build
47 | templ-install:
48 | @if ! command -v templ > /dev/null; then \
49 | read -p "Go's 'templ' is not installed on your machine. Do you want to install it? [Y/n] " choice; \
50 | if [ "$$choice" != "n" ] && [ "$$choice" != "N" ]; then \
51 | go install github.com/a-h/templ/cmd/templ@latest; \
52 | if [ ! -x "$$(command -v templ)" ]; then \
53 | echo "templ installation failed. Exiting..."; \
54 | exit 1; \
55 | fi; \
56 | else \
57 | echo "You chose not to install templ. Exiting..."; \
58 | exit 1; \
59 | fi; \
60 | fi
61 |
62 | tailwind-install:
63 | @if [ ! -f tailwindcss ]; then curl -sL https://github.com/tailwindlabs/tailwindcss/releases/latest/download/tailwindcss-linux-x64 -o tailwindcss; fi
64 | @chmod +x tailwindcss
65 |
66 | build: tailwind-install templ-install
67 | @echo "Building..."
68 | @templ generate
69 | @./tailwindcss -i cmd/web/styles/input.css -o cmd/web/assets/css/output.css
70 | @go build -o main cmd/api/main.go
71 | ```
72 |
73 | ## Use Tailwind CSS in your project
74 |
75 | By default, simple CSS examples are included in the codebase.
76 | Update base.templ and hello.templ, then rerun templ generate to see the changes at the `localhost:PORT/web` endpoint.
77 |
78 | 
79 |
--------------------------------------------------------------------------------
/docs/docs/installation.md:
--------------------------------------------------------------------------------
1 | ---
2 | hide:
3 | - toc
4 | ---
5 |
6 | Go-Blueprint provides a convenient CLI tool to effortlessly set up your Go projects. Follow the steps below to install the tool on your system.
7 |
8 | ## Binary Installation
9 |
10 | To install the Go-Blueprint CLI tool as a binary, run the following command:
11 |
12 | ```sh
13 | go install github.com/melkeydev/go-blueprint@latest
14 | ```
15 |
16 | This command installs the Go-Blueprint binary, automatically binding it to your `$GOPATH`.
17 |
18 | > If you’re using Zsh, you’ll need to add it manually to `~/.zshrc`.
19 |
20 | > After running the installation command, you need to update your `PATH` environment variable. To do this, you need to find out the correct `GOPATH` for your system. You can do this by running the following command:
21 | > Check your `GOPATH`
22 | >
23 | > ```
24 | > go env GOPATH
25 | > ```
26 | >
27 | > Then, add the following line to your `~/.zshrc` file:
28 | >
29 | > ```
30 | > GOPATH=$HOME/go PATH=$PATH:/usr/local/go/bin:$GOPATH/bin
31 | > ```
32 | >
33 | > Save the changes to your `~/.zshrc` file by running the following command:
34 | >
35 | > ```
36 | > source ~/.zshrc
37 | > ```
38 |
39 | ## NPM Install
40 |
41 | If you prefer using Node.js package manager, you can install Go-Blueprint via NPM. This method is convenient for developers who are already working in JavaScript/Node.js environments and want to integrate Go-Blueprint into their existing workflow.
42 |
43 | ```bash
44 | npm install -g @melkeydev/go-blueprint
45 | ```
46 |
47 | The `-g` flag installs Go-Blueprint globally, making it accessible from any directory on your system.
48 |
49 | ## Homebrew Install
50 |
51 | For macOS and Linux users, Homebrew provides a simple way to install Go-Blueprint. Homebrew automatically handles dependencies and keeps the tool updated through its package management system.
52 |
53 | ```bash
54 | brew install go-blueprint
55 | ```
56 |
57 | After installation via Homebrew, Go-Blueprint will be automatically added to your PATH, making it immediately available in your terminal.
58 |
59 | ## Building and Installing from Source
60 |
61 | If you prefer to build and install Go-Blueprint directly from the source code, you can follow these steps:
62 |
63 | Clone the Go-Blueprint repository from GitHub:
64 |
65 | ```sh
66 | git clone https://github.com/melkeydev/go-blueprint
67 | ```
68 |
69 | Build the Go-Blueprint binary:
70 |
71 | ```sh
72 | go build
73 | ```
74 |
75 | Install in your `$PATH` to make it accessible system-wide:
76 |
77 | ```sh
78 | go install
79 | ```
80 |
81 | Verify the installation by running:
82 |
83 | ```sh
84 | go-blueprint version
85 | ```
86 |
87 | This should display the version information of the installed Go-Blueprint.
88 |
89 | Now you have successfully built and installed Go-Blueprint from the source code.
90 |
--------------------------------------------------------------------------------
/docs/docs/creating-project/project-init.md:
--------------------------------------------------------------------------------
1 | ## Creating a Project
2 |
3 | After installing the Go-Blueprint CLI tool, you can create a new project with the default settings by running the following command:
4 |
5 | ```bash
6 | go-blueprint create
7 | ```
8 |
9 | This command will interactively guide you through the project setup process, allowing you to choose the project name, framework, and database driver.
10 |
11 | 
12 |
13 | ## Using Flags for Non-Interactive Setup
14 |
15 | For a non-interactive setup, you can use flags to provide the necessary information during project creation. Here's an example:
16 |
17 | ```
18 | go-blueprint create --name my-project --framework gin --driver postgres --git commit
19 | ```
20 |
21 | In this example:
22 |
23 | - `--name`: Specifies the name of the project (replace "my-project" with your desired project name).
24 | - `--framework`: Specifies the Go framework to be used (e.g., "gin").
25 | - `--driver`: Specifies the database driver to be integrated (e.g., "postgres").
26 | - `--git`: Specifies the git configuration option of the project (e.g., "commit").
27 |
28 | Customize the flags according to your project requirements.
29 |
30 | ## Advanced Flag
31 |
32 | By including the `--advanced` flag, users can choose one or all of the advanced features, HTMX, GitHub Actions for CI/CD, Websocket, Docker and TailwindCSS support, during the project creation process. The flag enhances the simplicity of Blueprint while offering flexibility for users who require additional functionality.
33 |
34 | ```bash
35 | go-blueprint create --advanced
36 | ```
37 |
38 | To recreate the project using the same configuration semi-interactively, use the following command:
39 | ```bash
40 | go-blueprint create --name my-project --framework chi --driver mysql --git commit --advanced
41 | ```
42 | This approach opens interactive mode only for advanced features, which allows you to choose the one or combination of available features.
43 |
44 | 
45 |
46 | ## Non-Interactive Setup
47 |
48 | Advanced features can be enabled using the `--feature` flag along with the `--advanced` flag:
49 |
50 | HTMX:
51 | ```bash
52 | go-blueprint create --advanced --feature htmx
53 | ```
54 |
55 | CI/CD workflow:
56 | ```bash
57 | go-blueprint create --advanced --feature githubaction
58 | ```
59 |
60 | Websocket:
61 | ```bash
62 | go-blueprint create --advanced --feature websocket
63 | ```
64 | TailwindCSS:
65 | ```bash
66 | go-blueprint create --advanced --feature tailwind
67 | ```
68 | Docker:
69 | ```bash
70 | go-blueprint create --advanced --feature docker
71 | ```
72 |
73 | Or all features at once:
74 | ```bash
75 | go-blueprint create --name my-project --framework chi --driver mysql --git commit --advanced --feature htmx --feature githubaction --feature websocket --feature tailwind --feature docker
76 | ```
77 |
--------------------------------------------------------------------------------
/cmd/template/framework/files/routes/gorilla.go.tmpl:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "encoding/json"
5 | "log"
6 | "net/http"
7 | {{if .AdvancedOptions.websocket}}
8 | "fmt"
9 | "time"
10 | {{end}}
11 |
12 | "github.com/gorilla/mux"
13 | {{.AdvancedTemplates.TemplateImports}}
14 | )
15 |
16 | func (s *Server) RegisterRoutes() http.Handler {
17 | r := mux.NewRouter()
18 |
19 | // Apply CORS middleware
20 | r.Use(s.corsMiddleware)
21 |
22 | r.HandleFunc("/", s.HelloWorldHandler)
23 | {{if ne .DBDriver "none"}}
24 | r.HandleFunc("/health", s.healthHandler)
25 | {{end}}
26 | {{if .AdvancedOptions.websocket}}
27 | r.HandleFunc("/websocket", s.websocketHandler)
28 | {{end}}
29 |
30 | {{.AdvancedTemplates.TemplateRoutes}}
31 |
32 | return r
33 | }
34 |
35 | // CORS middleware
36 | func (s *Server) corsMiddleware(next http.Handler) http.Handler {
37 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
38 | // CORS Headers
39 | w.Header().Set("Access-Control-Allow-Origin", "*") // Wildcard allows all origins
40 | w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS, PATCH")
41 | w.Header().Set("Access-Control-Allow-Headers", "Accept, Authorization, Content-Type")
42 | w.Header().Set("Access-Control-Allow-Credentials", "false") // Credentials not allowed with wildcard origins
43 |
44 | // Handle preflight OPTIONS requests
45 | if r.Method == http.MethodOptions {
46 | w.WriteHeader(http.StatusNoContent)
47 | return
48 | }
49 |
50 | next.ServeHTTP(w, r)
51 | })
52 | }
53 |
54 | func (s *Server) HelloWorldHandler(w http.ResponseWriter, r *http.Request) {
55 | resp := make(map[string]string)
56 | resp["message"] = "Hello World"
57 |
58 | jsonResp, err := json.Marshal(resp)
59 | if err != nil {
60 | log.Fatalf("error handling JSON marshal. Err: %v", err)
61 | }
62 |
63 | _, _ = w.Write(jsonResp)
64 | }
65 |
66 | {{if ne .DBDriver "none"}}
67 | func (s *Server) healthHandler(w http.ResponseWriter, r *http.Request) {
68 | jsonResp, err := json.Marshal(s.db.Health())
69 |
70 | if err != nil {
71 | log.Fatalf("error handling JSON marshal. Err: %v", err)
72 | }
73 |
74 | _, _ = w.Write(jsonResp)
75 | }
76 | {{end}}
77 |
78 | {{if .AdvancedOptions.websocket}}
79 | func (s *Server) websocketHandler(w http.ResponseWriter, r *http.Request) {
80 | socket, err := websocket.Accept(w, r, nil)
81 |
82 | if err != nil {
83 | log.Printf("could not open websocket: %v", err)
84 | _, _ = w.Write([]byte("could not open websocket"))
85 | w.WriteHeader(http.StatusInternalServerError)
86 | return
87 | }
88 |
89 | defer socket.Close(websocket.StatusGoingAway, "server closing websocket")
90 |
91 | ctx := r.Context()
92 | socketCtx := socket.CloseRead(ctx)
93 |
94 | for {
95 | payload := fmt.Sprintf("server timestamp: %d", time.Now().UnixNano())
96 | err := socket.Write(socketCtx, websocket.MessageText, []byte(payload))
97 | if err != nil {
98 | break
99 | }
100 | time.Sleep(time.Second * 2)
101 | }
102 | }
103 | {{end}}
104 |
105 |
--------------------------------------------------------------------------------
/cmd/template/framework/files/routes/http_router.go.tmpl:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "encoding/json"
5 | "log"
6 | "net/http"
7 | {{if .AdvancedOptions.websocket}}
8 | "fmt"
9 | "time"
10 | {{end}}
11 |
12 | "github.com/julienschmidt/httprouter"
13 | {{.AdvancedTemplates.TemplateImports}}
14 | )
15 |
16 | func (s *Server) RegisterRoutes() http.Handler {
17 | r := httprouter.New()
18 |
19 | // Wrap all routes with CORS middleware
20 | corsWrapper := s.corsMiddleware(r)
21 |
22 | r.HandlerFunc(http.MethodGet, "/", s.HelloWorldHandler)
23 | {{if ne .DBDriver "none"}}
24 | r.HandlerFunc(http.MethodGet, "/health", s.healthHandler)
25 | {{end}}
26 | {{if .AdvancedOptions.websocket}}
27 | r.HandlerFunc(http.MethodGet, "/websocket", s.websocketHandler)
28 | {{end}}
29 | {{.AdvancedTemplates.TemplateRoutes}}
30 |
31 | return corsWrapper
32 | }
33 |
34 | // CORS middleware
35 | func (s *Server) corsMiddleware(next http.Handler) http.Handler {
36 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
37 | // CORS headers
38 | w.Header().Set("Access-Control-Allow-Origin", "*") // Use "*" for all origins, or replace with specific origins
39 | w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS, PATCH")
40 | w.Header().Set("Access-Control-Allow-Headers", "Accept, Authorization, Content-Type, X-CSRF-Token")
41 | w.Header().Set("Access-Control-Allow-Credentials", "false") // Set to "true" if credentials are needed
42 |
43 | // Handle preflight OPTIONS requests
44 | if r.Method == http.MethodOptions {
45 | w.WriteHeader(http.StatusNoContent)
46 | return
47 | }
48 |
49 | next.ServeHTTP(w, r)
50 | })
51 | }
52 |
53 | func (s *Server) HelloWorldHandler(w http.ResponseWriter, r *http.Request) {
54 | resp := make(map[string]string)
55 | resp["message"] = "Hello World"
56 |
57 | jsonResp, err := json.Marshal(resp)
58 | if err != nil {
59 | log.Fatalf("error handling JSON marshal. Err: %v", err)
60 | }
61 |
62 | _, _ = w.Write(jsonResp)
63 | }
64 |
65 | {{if ne .DBDriver "none"}}
66 | func (s *Server) healthHandler(w http.ResponseWriter, r *http.Request) {
67 | jsonResp, err := json.Marshal(s.db.Health())
68 |
69 | if err != nil {
70 | log.Fatalf("error handling JSON marshal. Err: %v", err)
71 | }
72 |
73 | _, _ = w.Write(jsonResp)
74 | }
75 | {{end}}
76 |
77 | {{if .AdvancedOptions.websocket}}
78 | func (s *Server) websocketHandler(w http.ResponseWriter, r *http.Request) {
79 | socket, err := websocket.Accept(w, r, nil)
80 |
81 | if err != nil {
82 | log.Printf("could not open websocket: %v", err)
83 | _, _ = w.Write([]byte("could not open websocket"))
84 | w.WriteHeader(http.StatusInternalServerError)
85 | return
86 | }
87 |
88 | defer socket.Close(websocket.StatusGoingAway, "server closing websocket")
89 |
90 | ctx := r.Context()
91 | socketCtx := socket.CloseRead(ctx)
92 |
93 | for {
94 | payload := fmt.Sprintf("server timestamp: %d", time.Now().UnixNano())
95 | err := socket.Write(socketCtx, websocket.MessageText, []byte(payload))
96 | if err != nil {
97 | break
98 | }
99 | time.Sleep(time.Second * 2)
100 | }
101 | }
102 | {{end}}
103 |
104 |
--------------------------------------------------------------------------------
/.github/workflows/update-htmx-version.yml:
--------------------------------------------------------------------------------
1 | name: Check for new htmx release
2 |
3 | on:
4 | schedule:
5 | - cron: '0 0 * * Sun'
6 |
7 | jobs:
8 | check_release:
9 | runs-on: ubuntu-latest
10 | steps:
11 | - uses: actions/checkout@v4
12 |
13 | - name: Get version from file
14 | id: get_version_file
15 | run: |
16 | VERSION_FILE=$(curl -s https://raw.githubusercontent.com/Melkeydev/go-blueprint/main/cmd/template/advanced/files/htmx/htmx.min.js.tmpl | grep version | awk -F'"' '{print "v" $2}')
17 | echo "version file: $VERSION_FILE"
18 | if [[ "$VERSION_FILE" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
19 | echo "version_file=$VERSION_FILE" >> $GITHUB_OUTPUT
20 | else
21 | echo "Invalid VERSION_FILE format: $VERSION_FILE" >&2
22 | exit 1
23 | fi
24 |
25 | - name: Get version from GitHub API
26 | id: get_version_api
27 | run: |
28 | VERSION_API=$(curl -s https://api.github.com/repos/bigskysoftware/htmx/releases/latest | jq -r '.tag_name')
29 | echo "version api: $VERSION_API"
30 | if [[ "$VERSION_API" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
31 | echo "version_api=$VERSION_API" >> $GITHUB_OUTPUT
32 | else
33 | echo "Invalid VERSION_API format: $VERSION_API" >&2
34 | exit 1
35 | fi
36 |
37 | - name: Compare versions
38 | id: compare_versions
39 | run: |
40 | if [ "${{ steps.get_version_api.outputs.version_api }}" != "${{ steps.get_version_file.outputs.version_file }}" ]; then
41 | echo "release_changed=true" >> $GITHUB_OUTPUT
42 | echo "Release changed: true"
43 | else
44 | echo "release_changed=false" >> $GITHUB_OUTPUT
45 | echo "Release changed: false"
46 | fi
47 |
48 | - name: dump latest htmx version
49 | if: steps.compare_versions.outputs.release_changed == 'true'
50 | run: curl -L https://github.com/bigskysoftware/htmx/releases/latest/download/htmx.min.js -o cmd/template/advanced/files/htmx/htmx.min.js
51 |
52 | - name: Prettify code
53 | if: steps.compare_versions.outputs.release_changed == 'true'
54 | run: |
55 | npm install --save-dev --save-exact prettier
56 | npx prettier --write cmd/template/advanced/files/htmx/htmx.min.js
57 | rm -rf node_modules
58 | rm package-lock.json
59 | rm package.json
60 |
61 | - name: Create tmpl after Prettify
62 | if: steps.compare_versions.outputs.release_changed == 'true'
63 | run: mv cmd/template/advanced/files/htmx/htmx.min.js cmd/template/advanced/files/htmx/htmx.min.js.tmpl
64 |
65 | - name: Create Pull Request
66 | if: steps.compare_versions.outputs.release_changed == 'true'
67 | uses: peter-evans/create-pull-request@v6
68 | with:
69 | commit-message: update htmx version ${{ steps.get_version_api.outputs.version_api }}
70 | title: Update htmx to version ${{ steps.get_version_api.outputs.version_api }} [Bot]
71 | body: New htmx ${{ steps.get_version_api.outputs.version_api }} version is available. This is an automatic PR to update changes.
72 | branch: htmx-version-update
73 | base: main
74 |
--------------------------------------------------------------------------------
/cmd/template/framework/files/routes/standard_library.go.tmpl:
--------------------------------------------------------------------------------
1 | package server
2 |
3 | import (
4 | "encoding/json"
5 | "log"
6 | "net/http"
7 | {{if .AdvancedOptions.websocket}}
8 | "fmt"
9 | "time"
10 | {{end}}
11 |
12 | {{.AdvancedTemplates.TemplateImports}}
13 | )
14 |
15 | func (s *Server) RegisterRoutes() http.Handler {
16 | mux := http.NewServeMux()
17 |
18 | // Register routes
19 | mux.HandleFunc("/", s.HelloWorldHandler)
20 | {{if ne .DBDriver "none"}}
21 | mux.HandleFunc("/health", s.healthHandler)
22 | {{end}}
23 | {{if .AdvancedOptions.websocket}}
24 | mux.HandleFunc("/websocket", s.websocketHandler)
25 | {{end}}
26 | {{.AdvancedTemplates.TemplateRoutes}}
27 |
28 | // Wrap the mux with CORS middleware
29 | return s.corsMiddleware(mux)
30 | }
31 |
32 | func (s *Server) corsMiddleware(next http.Handler) http.Handler {
33 | return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
34 | // Set CORS headers
35 | w.Header().Set("Access-Control-Allow-Origin", "*") // Replace "*" with specific origins if needed
36 | w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS, PATCH")
37 | w.Header().Set("Access-Control-Allow-Headers", "Accept, Authorization, Content-Type, X-CSRF-Token")
38 | w.Header().Set("Access-Control-Allow-Credentials", "false") // Set to "true" if credentials are required
39 |
40 | // Handle preflight OPTIONS requests
41 | if r.Method == http.MethodOptions {
42 | w.WriteHeader(http.StatusNoContent)
43 | return
44 | }
45 |
46 | // Proceed with the next handler
47 | next.ServeHTTP(w, r)
48 | })
49 | }
50 |
51 | func (s *Server) HelloWorldHandler(w http.ResponseWriter, r *http.Request) {
52 | resp := map[string]string{"message": "Hello World"}
53 | jsonResp, err := json.Marshal(resp)
54 | if err != nil {
55 | http.Error(w, "Failed to marshal response", http.StatusInternalServerError)
56 | return
57 | }
58 | w.Header().Set("Content-Type", "application/json")
59 | if _, err := w.Write(jsonResp); err != nil {
60 | log.Printf("Failed to write response: %v", err)
61 | }
62 | }
63 |
64 | {{if ne .DBDriver "none"}}
65 | func (s *Server) healthHandler(w http.ResponseWriter, r *http.Request) {
66 | resp, err := json.Marshal(s.db.Health())
67 | if err != nil {
68 | http.Error(w, "Failed to marshal health check response", http.StatusInternalServerError)
69 | return
70 | }
71 | w.Header().Set("Content-Type", "application/json")
72 | if _, err := w.Write(resp); err != nil {
73 | log.Printf("Failed to write response: %v", err)
74 | }
75 | }
76 | {{end}}
77 |
78 | {{if .AdvancedOptions.websocket}}
79 | func (s *Server) websocketHandler(w http.ResponseWriter, r *http.Request) {
80 | socket, err := websocket.Accept(w, r, nil)
81 | if err != nil {
82 | http.Error(w, "Failed to open websocket", http.StatusInternalServerError)
83 | return
84 | }
85 | defer socket.Close(websocket.StatusGoingAway, "Server closing websocket")
86 |
87 | ctx := r.Context()
88 | socketCtx := socket.CloseRead(ctx)
89 |
90 | for {
91 | payload := fmt.Sprintf("server timestamp: %d", time.Now().UnixNano())
92 | if err := socket.Write(socketCtx, websocket.MessageText, []byte(payload)); err != nil {
93 | log.Printf("Failed to write to socket: %v", err)
94 | break
95 | }
96 | time.Sleep(2 * time.Second)
97 | }
98 | }
99 | {{end}}
100 |
101 |
--------------------------------------------------------------------------------
/cmd/template/dbdriver/files/tests/scylla.tmpl:
--------------------------------------------------------------------------------
1 | package database
2 |
3 | import (
4 | "context"
5 | "fmt"
6 | "github.com/docker/go-connections/nat"
7 | "github.com/testcontainers/testcontainers-go"
8 | "github.com/testcontainers/testcontainers-go/wait"
9 | "io"
10 | "log"
11 | "strings"
12 | "testing"
13 | )
14 |
15 | const (
16 | port = nat.Port("19042/tcp")
17 | )
18 |
19 | func mustStartScyllaDBContainer() (testcontainers.Container, error) {
20 |
21 | // Define the container
22 | image := "scylladb/scylla:6.2"
23 | exposedPorts := []string{"9042/tcp", "19042/tcp"}
24 | commands := []string{
25 | "--smp=2",
26 | "--memory=1G",
27 | "--developer-mode=1",
28 | "--overprovisioned=1",
29 | }
30 |
31 | req := testcontainers.ContainerRequest{
32 | FromDockerfile: testcontainers.FromDockerfile{},
33 | Image: image,
34 | ExposedPorts: exposedPorts,
35 | Cmd: commands,
36 | WaitingFor: wait.ForAll(
37 | wait.ForLog(".*initialization completed.").AsRegexp(),
38 | wait.ForListeningPort(port),
39 | wait.ForExec([]string{"cqlsh", "-e", "SELECT bootstrapped FROM system.local"}).WithResponseMatcher(func(body io.Reader) bool {
40 | data, _ := io.ReadAll(body)
41 | return strings.Contains(string(data), "COMPLETED")
42 | }),
43 | ),
44 | }
45 |
46 | // Start the container
47 | scyllaDBContainer, err := testcontainers.GenericContainer(
48 | context.Background(), testcontainers.GenericContainerRequest{
49 | ContainerRequest: req,
50 | Started: true,
51 | })
52 | if err != nil {
53 | return nil, err
54 | }
55 |
56 | mappedPort, err := scyllaDBContainer.MappedPort(context.Background(), "19042/tcp")
57 | if err != nil {
58 | return nil, err
59 | }
60 |
61 | hosts = fmt.Sprintf("localhost:%v", mappedPort.Port())
62 |
63 | return scyllaDBContainer, nil
64 | }
65 |
66 | func TestMain(m *testing.M) {
67 |
68 | container, err := mustStartScyllaDBContainer()
69 | if err != nil {
70 | log.Fatalf("could not start scylla container: %v", err)
71 | }
72 |
73 | m.Run()
74 |
75 | err = container.Terminate(context.Background())
76 | if err != nil {
77 | return
78 | }
79 |
80 | }
81 |
82 | func TestNew(t *testing.T) {
83 | srv := New()
84 | if srv == nil {
85 | t.Fatal("New() returned nil")
86 | }
87 |
88 | err := srv.Close()
89 | if err != nil {
90 | t.Fatalf("expected Close() to return nil")
91 | }
92 | }
93 |
94 | func TestHealth(t *testing.T) {
95 | srv := New()
96 |
97 | stats := srv.Health()
98 |
99 | if stats["status"] != "up" {
100 | t.Fatalf("expected status to be up, got %s", stats["status"])
101 | }
102 |
103 | if _, ok := stats["error"]; ok {
104 | t.Fatalf("expected error not to be present")
105 | }
106 |
107 | if stats["message"] != "It's healthy" {
108 | t.Fatalf("expected message to be 'It's healthy', got %s", stats["message"])
109 | }
110 |
111 | if stats["scylla_cluster_nodes_up"] != "1" {
112 | t.Fatalf("expected nodes up '1', got %s", stats["scylla_cluster_nodes_up"])
113 | }
114 |
115 | if stats["scylla_cluster_nodes_down"] != "0" {
116 | t.Fatalf("expected nodes down '0', got %s", stats["scylla_cluster_nodes_down"])
117 | }
118 |
119 | if stats["scylla_current_datacenter"] != "datacenter1" {
120 | t.Fatalf("expected connected dc 'datacenter', got %s", stats["scylla_current_datacenter"])
121 | }
122 |
123 | err := srv.Close()
124 | if err != nil {
125 | t.Fatalf("expected Close() to return nil")
126 | }
127 | }
128 |
129 | func TestClose(t *testing.T) {
130 | srv := New()
131 |
132 | if srv.Close() != nil {
133 | t.Fatalf("expected Close() to return nil")
134 | }
135 | }
136 |
--------------------------------------------------------------------------------
/docs/docs/endpoints-test/sql.md:
--------------------------------------------------------------------------------
1 | To test the SQL DB Health Check endpoint, use the following curl command:
2 |
3 | ```bash
4 | curl http://localhost:PORT/health
5 | ```
6 | ## Health Function
7 |
8 | The `Health` function checks the health of the database connection by pinging the database and retrieving various statistics. It returns a map with keys indicating different health metrics.
9 |
10 | ### Functionality
11 |
12 | **Ping the Database**: The function pings the database to ensure it is reachable.
13 |
14 | - If the database is down, it logs the error, sets the status to "down," and terminates the program.
15 | - If the database is up, it proceeds to gather additional statistics.
16 |
17 | **Collect Database Statistics**: The function retrieves the following statistics from the database connection:
18 |
19 | - `open_connections`: Number of open connections to the database.
20 | - `in_use`: Number of connections currently in use.
21 | - `idle`: Number of idle connections.
22 | - `wait_count`: Number of times a connection has to wait.
23 | - `wait_duration`: Total time connections have spent waiting.
24 | - `max_idle_closed`: Number of connections closed due to exceeding idle time.
25 | - `max_lifetime_closed`: Number of connections closed due to exceeding their lifetime.
26 |
27 | **Evaluate Statistics**: Evaluates the collected statistics to provide a health message. Based on predefined thresholds, it updates the health message to indicate potential issues, such as heavy load or high wait events.
28 |
29 | ### Sample Output
30 |
31 | The `Health` function returns a JSON-like map structure with the following keys and example values:
32 |
33 | ```json
34 | {
35 | "idle": "1",
36 | "in_use": "0",
37 | "max_idle_closed": "0",
38 | "max_lifetime_closed": "0",
39 | "message": "It's healthy",
40 | "open_connections": "1",
41 | "status": "up",
42 | "wait_count": "0",
43 | "wait_duration": "0s"
44 | }
45 | ```
46 |
47 | ## Code Implementation
48 |
49 | ```go
50 | func (s *service) Health() map[string]string {
51 | ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
52 | defer cancel()
53 |
54 | stats := make(map[string]string)
55 |
56 | err := s.db.PingContext(ctx)
57 | if err != nil {
58 | stats["status"] = "down"
59 | stats["error"] = fmt.Sprintf("db down: %v", err)
60 | log.Fatalf("db down: %v", err)
61 | return stats
62 | }
63 |
64 | stats["status"] = "up"
65 | stats["message"] = "It's healthy"
66 |
67 | dbStats := s.db.Stats()
68 | stats["open_connections"] = strconv.Itoa(dbStats.OpenConnections)
69 | stats["in_use"] = strconv.Itoa(dbStats.InUse)
70 | stats["idle"] = strconv.Itoa(dbStats.Idle)
71 | stats["wait_count"] = strconv.FormatInt(dbStats.WaitCount, 10)
72 | stats["wait_duration"] = dbStats.WaitDuration.String()
73 | stats["max_idle_closed"] = strconv.FormatInt(dbStats.MaxIdleClosed, 10)
74 | stats["max_lifetime_closed"] = strconv.FormatInt(dbStats.MaxLifetimeClosed, 10)
75 |
76 | if dbStats.OpenConnections > 40 {
77 | stats["message"] = "The database is experiencing heavy load."
78 | }
79 |
80 | if dbStats.WaitCount > 1000 {
81 | stats["message"] = "The database has a high number of wait events, indicating potential bottlenecks."
82 | }
83 |
84 | if dbStats.MaxIdleClosed > int64(dbStats.OpenConnections)/2 {
85 | stats["message"] = "Many idle connections are being closed, consider revising the connection pool settings."
86 | }
87 |
88 | if dbStats.MaxLifetimeClosed > int64(dbStats.OpenConnections)/2 {
89 | stats["message"] = "Many connections are being closed due to max lifetime, consider increasing max lifetime or revising the connection usage pattern."
90 | }
91 |
92 | return stats
93 | }
94 | ```
95 |
--------------------------------------------------------------------------------
/cmd/ui/textinput/textinput.go:
--------------------------------------------------------------------------------
1 | // Package textinput provides functions that
2 | // help define and draw a text-input step
3 | package textinput
4 |
5 | import (
6 | "errors"
7 | "fmt"
8 | "regexp"
9 |
10 | "github.com/charmbracelet/bubbles/textinput"
11 | tea "github.com/charmbracelet/bubbletea"
12 | "github.com/charmbracelet/lipgloss"
13 | "github.com/melkeydev/go-blueprint/cmd/program"
14 | )
15 |
16 | var (
17 | titleStyle = lipgloss.NewStyle().Background(lipgloss.Color("#01FAC6")).Foreground(lipgloss.Color("#030303")).Bold(true).Padding(0, 1, 0)
18 | errorStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("#FF8700")).Bold(true).Padding(0, 0, 0)
19 | )
20 |
21 | type (
22 | errMsg error
23 | )
24 |
25 | // Output represents the text provided in a textinput step
26 | type Output struct {
27 | Output string
28 | }
29 |
30 | // Output.update updates the value of the Output
31 | func (o *Output) update(val string) {
32 | o.Output = val
33 | }
34 |
35 | // A textnput.model contains the data for the textinput step.
36 | //
37 | // It has the required methods that make it a bubbletea.Model
38 | type model struct {
39 | textInput textinput.Model
40 | err error
41 | output *Output
42 | header string
43 | exit *bool
44 | }
45 |
46 | // sanitizeInput verifies that an input text string gets validated
47 | func sanitizeInput(input string) error {
48 | matched, err := regexp.MatchString("^[a-zA-Z0-9_\\/.-]+$", input)
49 | if !matched {
50 | return fmt.Errorf("string violates the input regex pattern, err: %v", err)
51 | }
52 | return nil
53 | }
54 |
55 | // InitialTextInputModel initializes a textinput step
56 | // with the given data
57 | func InitialTextInputModel(output *Output, header string, program *program.Project) model {
58 | ti := textinput.New()
59 | ti.Focus()
60 | ti.CharLimit = 156
61 | ti.Width = 20
62 | ti.Validate = sanitizeInput
63 |
64 | return model{
65 | textInput: ti,
66 | err: nil,
67 | output: output,
68 | header: titleStyle.Render(header),
69 | exit: &program.Exit,
70 | }
71 | }
72 |
73 | // CreateErrorInputModel creates a textinput step
74 | // with the given error
75 | func CreateErrorInputModel(err error) model {
76 | ti := textinput.New()
77 | ti.Focus()
78 | ti.CharLimit = 156
79 | ti.Width = 20
80 | exit := true
81 |
82 | return model{
83 | textInput: ti,
84 | err: errors.New(errorStyle.Render(err.Error())),
85 | output: nil,
86 | header: "",
87 | exit: &exit,
88 | }
89 | }
90 |
91 | // Init is called at the beginning of a textinput step
92 | // and sets the cursor to blink
93 | func (m model) Init() tea.Cmd {
94 | return textinput.Blink
95 | }
96 |
97 | // Update is called when "things happen", it checks for the users text input,
98 | // and for Ctrl+C or Esc to close the program.
99 | func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
100 | var cmd tea.Cmd
101 |
102 | switch msg := msg.(type) {
103 | case tea.KeyMsg:
104 | switch msg.Type {
105 | case tea.KeyEnter:
106 | if len(m.textInput.Value()) > 1 {
107 | m.output.update(m.textInput.Value())
108 | return m, tea.Quit
109 | }
110 | case tea.KeyCtrlC, tea.KeyEsc:
111 | *m.exit = true
112 | return m, tea.Quit
113 | }
114 |
115 | // We handle errors just like any other message
116 | case errMsg:
117 | m.err = msg
118 | *m.exit = true
119 | return m, nil
120 | }
121 |
122 | m.textInput, cmd = m.textInput.Update(msg)
123 | return m, cmd
124 | }
125 |
126 | // View is called to draw the textinput step
127 | func (m model) View() string {
128 | return fmt.Sprintf("%s\n\n%s\n\n",
129 | m.header,
130 | m.textInput.View(),
131 | )
132 | }
133 |
134 | func (m model) Err() string {
135 | return m.err.Error()
136 | }
137 |
--------------------------------------------------------------------------------
/cmd/template/dbdriver/files/service/sqlite.tmpl:
--------------------------------------------------------------------------------
1 | package database
2 |
3 | import (
4 | "context"
5 | "database/sql"
6 | "fmt"
7 | "log"
8 | "os"
9 | "strconv"
10 | "time"
11 |
12 | _ "github.com/mattn/go-sqlite3"
13 | _ "github.com/joho/godotenv/autoload"
14 | )
15 |
16 | // Service represents a service that interacts with a database.
17 | type Service interface {
18 | // Health returns a map of health status information.
19 | // The keys and values in the map are service-specific.
20 | Health() map[string]string
21 |
22 | // Close terminates the database connection.
23 | // It returns an error if the connection cannot be closed.
24 | Close() error
25 | }
26 |
27 | type service struct {
28 | db *sql.DB
29 | }
30 |
31 | var (
32 | dburl = os.Getenv("BLUEPRINT_DB_URL")
33 | dbInstance *service
34 | )
35 |
36 | func New() Service {
37 | // Reuse Connection
38 | if dbInstance != nil {
39 | return dbInstance
40 | }
41 |
42 | db, err := sql.Open("sqlite3", dburl)
43 | if err != nil {
44 | // This will not be a connection error, but a DSN parse error or
45 | // another initialization error.
46 | log.Fatal(err)
47 | }
48 |
49 | dbInstance = &service{
50 | db: db,
51 | }
52 | return dbInstance
53 | }
54 |
55 | // Health checks the health of the database connection by pinging the database.
56 | // It returns a map with keys indicating various health statistics.
57 | func (s *service) Health() map[string]string {
58 | ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
59 | defer cancel()
60 |
61 | stats := make(map[string]string)
62 |
63 | // Ping the database
64 | err := s.db.PingContext(ctx)
65 | if err != nil {
66 | stats["status"] = "down"
67 | stats["error"] = fmt.Sprintf("db down: %v", err)
68 | log.Fatalf("db down: %v", err) // Log the error and terminate the program
69 | return stats
70 | }
71 |
72 | // Database is up, add more statistics
73 | stats["status"] = "up"
74 | stats["message"] = "It's healthy"
75 |
76 | // Get database stats (like open connections, in use, idle, etc.)
77 | dbStats := s.db.Stats()
78 | stats["open_connections"] = strconv.Itoa(dbStats.OpenConnections)
79 | stats["in_use"] = strconv.Itoa(dbStats.InUse)
80 | stats["idle"] = strconv.Itoa(dbStats.Idle)
81 | stats["wait_count"] = strconv.FormatInt(dbStats.WaitCount, 10)
82 | stats["wait_duration"] = dbStats.WaitDuration.String()
83 | stats["max_idle_closed"] = strconv.FormatInt(dbStats.MaxIdleClosed, 10)
84 | stats["max_lifetime_closed"] = strconv.FormatInt(dbStats.MaxLifetimeClosed, 10)
85 |
86 | // Evaluate stats to provide a health message
87 | if dbStats.OpenConnections > 40 { // Assuming 50 is the max for this example
88 | stats["message"] = "The database is experiencing heavy load."
89 | }
90 |
91 | if dbStats.WaitCount > 1000 {
92 | stats["message"] = "The database has a high number of wait events, indicating potential bottlenecks."
93 | }
94 |
95 | if dbStats.MaxIdleClosed > int64(dbStats.OpenConnections)/2 {
96 | stats["message"] = "Many idle connections are being closed, consider revising the connection pool settings."
97 | }
98 |
99 | if dbStats.MaxLifetimeClosed > int64(dbStats.OpenConnections)/2 {
100 | stats["message"] = "Many connections are being closed due to max lifetime, consider increasing max lifetime or revising the connection usage pattern."
101 | }
102 |
103 | return stats
104 | }
105 |
106 | // Close closes the database connection.
107 | // It logs a message indicating the disconnection from the specific database.
108 | // If the connection is successfully closed, it returns nil.
109 | // If an error occurs while closing the connection, it returns the error.
110 | func (s *service) Close() error {
111 | log.Printf("Disconnected from database: %s", dburl)
112 | return s.db.Close()
113 | }
114 |
--------------------------------------------------------------------------------
/docs/docs/blueprint-core/db-drivers.md:
--------------------------------------------------------------------------------
1 | To extend the project with database functionality, users can choose from a variety of Go database drivers. Each driver is tailored to work with specific database systems, providing flexibility based on project requirements:
2 |
3 | 1. [Mongo](https://go.mongodb.org/mongo-driver): Provides necessary tools for connecting and interacting with MongoDB databases.
4 | 2. [Mysql](https://github.com/go-sql-driver/mysql): Enables seamless integration with MySQL databases.
5 | 3. [Postgres](https://github.com/jackc/pgx/): Facilitates connectivity to PostgreSQL databases.
6 | 4. [Redis](https://github.com/redis/go-redis): Provides tools for connecting and interacting with Redis.
7 | 5. [Sqlite](https://github.com/mattn/go-sqlite3): Suitable for projects requiring a lightweight, self-contained database.
8 | 6. [ScyllaDB](https://github.com/scylladb/gocql): Facilitates connectivity to ScyllaDB databases.
9 |
10 | ## Updated Project Structure
11 |
12 | Integrating a database adds a new layer to the project structure, primarily in the `internal/database` directory:
13 |
14 | ```bash
15 | /(Root)
16 | ├── /cmd
17 | │ └── /api
18 | │ └── main.go
19 | ├── /internal
20 | │ ├── /database
21 | │ │ ├── database_test.go
22 | │ │ └── database.go
23 | │ └── /server
24 | │ ├── routes.go
25 | │ ├── routes_test.go
26 | │ └── server.go
27 | ├── go.mod
28 | ├── go.sum
29 | ├── Makefile
30 | └── README.md
31 | ```
32 |
33 | ## Database Driver Implementation
34 |
35 | Users can select the desired database driver based on their project's specific needs. The chosen driver is then imported into the project, and the `database.go` file is adjusted accordingly to establish a connection and manage interactions with the selected database.
36 |
37 | ## Integration Tests for Database Operations
38 |
39 | For all the database drivers but `Sqlite`, integration tests are automatically generated to ensure that the database connection is working correctly. It uses [Testcontainers for Go](https://golang.testcontainers.org/) to spin up a containerized instance of the database server, run the tests, and then tear down the container.
40 |
41 | [Testcontainers for Go](https://golang.testcontainers.org/) is a Go package that makes it simple to create and clean up container-based dependencies for automated integration/smoke tests. The clean, easy-to-use API enables developers to programmatically define containers that should be run as part of a test and clean up those resources when the test is done.
42 |
43 |
44 | ### Requirements
45 |
46 | You need a container runtime installed on your machine. Testcontainers supports Docker and any other container runtime that implements the Docker APIs.
47 |
48 | To install Docker:
49 |
50 | ```bash
51 | curl -sLO get.docker.com
52 | ```
53 |
54 | ### Running the tests
55 |
56 | Go to the `internal/database` directory and run the following command:
57 |
58 | ```bash
59 | go test -v
60 | ```
61 |
62 | Or, just run the following command from the root directory:
63 |
64 | ```bash
65 | make itest
66 | ```
67 |
68 | Testcontainers automatically pulls the required Docker images and start the containers. The tests run against the containers, and once the tests are done, the containers are stopped and removed. For further information, refer to the [official documentation](https://golang.testcontainers.org/).
69 |
70 | ## Docker-Compose for Quick Database Spinup
71 |
72 | To facilitate quick setup and testing, a `docker-compose.yml` file is provided. This file defines a service for the chosen database system with the necessary environment variables. Running `docker-compose up` will quickly spin up a containerized instance of the database, allowing users to test their application against a real database server.
73 |
74 | This Docker Compose approach simplifies the process of setting up a database for development or testing purposes, providing a convenient and reproducible environment for the project.
75 |
--------------------------------------------------------------------------------
/cmd/ui/multiSelect/multiSelect.go:
--------------------------------------------------------------------------------
1 | // Package multiSelect provides functions that
2 | // help define and draw a multi-select step
3 | package multiSelect
4 |
5 | import (
6 | "fmt"
7 |
8 | "github.com/melkeydev/go-blueprint/cmd/program"
9 | "github.com/melkeydev/go-blueprint/cmd/steps"
10 |
11 | tea "github.com/charmbracelet/bubbletea"
12 | "github.com/charmbracelet/lipgloss"
13 | )
14 |
15 | // Change this
16 | var (
17 | focusedStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("#01FAC6")).Bold(true)
18 | titleStyle = lipgloss.NewStyle().Background(lipgloss.Color("#01FAC6")).Foreground(lipgloss.Color("#030303")).Bold(true).Padding(0, 1, 0)
19 | selectedItemStyle = lipgloss.NewStyle().PaddingLeft(1).Foreground(lipgloss.Color("170")).Bold(true)
20 | selectedItemDescStyle = lipgloss.NewStyle().PaddingLeft(1).Foreground(lipgloss.Color("170"))
21 | descriptionStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("#40BDA3"))
22 | )
23 |
24 | // A Selection represents a choice made in a multiSelect step
25 | type Selection struct {
26 | Choices map[string]bool
27 | }
28 |
29 | // Update changes the value of a Selection's Choice
30 | func (s *Selection) Update(optionName string, value bool) {
31 | s.Choices[optionName] = value
32 | }
33 |
34 | // A multiSelect.model contains the data for the multiSelect step.
35 | //
36 | // It has the required methods that make it a bubbletea.Model
37 | type model struct {
38 | cursor int
39 | options []steps.Item
40 | selected map[int]struct{}
41 | choices *Selection
42 | header string
43 | exit *bool
44 | }
45 |
46 | func (m model) Init() tea.Cmd {
47 | return nil
48 | }
49 |
50 | // InitialModelMulti initializes a multiSelect step with
51 | // the given data
52 | func InitialModelMultiSelect(options []steps.Item, selection *Selection, header string, program *program.Project) model {
53 | return model{
54 | options: options,
55 | selected: make(map[int]struct{}),
56 | choices: selection,
57 | header: titleStyle.Render(header),
58 | exit: &program.Exit,
59 | }
60 | }
61 |
62 | // Update is called when "things happen", it checks for
63 | // important keystrokes to signal when to quit, change selection,
64 | // and confirm the selection.
65 | func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
66 | switch msg := msg.(type) {
67 | case tea.KeyMsg:
68 | switch msg.String() {
69 | case "ctrl+c", "q":
70 | *m.exit = true
71 | return m, tea.Quit
72 | case "up", "k":
73 | if m.cursor > 0 {
74 | m.cursor--
75 | }
76 | case "down", "j":
77 | if m.cursor < len(m.options)-1 {
78 | m.cursor++
79 | }
80 | case "enter", " ":
81 | _, ok := m.selected[m.cursor]
82 | if ok {
83 | delete(m.selected, m.cursor)
84 | } else {
85 | m.selected[m.cursor] = struct{}{}
86 | }
87 | case "y":
88 | for selectedKey := range m.selected {
89 | m.choices.Update(m.options[selectedKey].Flag, true)
90 | m.cursor = selectedKey
91 | }
92 | return m, tea.Quit
93 | }
94 | }
95 | return m, nil
96 | }
97 |
98 | // View is called to draw the multiSelect step
99 | func (m model) View() string {
100 | s := m.header + "\n\n"
101 |
102 | for i, option := range m.options {
103 | cursor := " "
104 | if m.cursor == i {
105 | cursor = focusedStyle.Render(">")
106 | option.Title = selectedItemStyle.Render(option.Title)
107 | option.Desc = selectedItemDescStyle.Render(option.Desc)
108 | }
109 |
110 | checked := " "
111 | if _, ok := m.selected[i]; ok {
112 | checked = focusedStyle.Render("*")
113 | }
114 |
115 | title := focusedStyle.Render(option.Title)
116 | description := descriptionStyle.Render(option.Desc)
117 |
118 | s += fmt.Sprintf("%s [%s] %s\n%s\n\n", cursor, checked, title, description)
119 | }
120 |
121 | s += fmt.Sprintf("Press %s to confirm choice.\n", focusedStyle.Render("y"))
122 | return s
123 | }
124 |
--------------------------------------------------------------------------------
/docs/docs/advanced-flag/docker.md:
--------------------------------------------------------------------------------
1 | The Docker advanced flag provides the app's Dockerfile configuration and creates or updates the docker-compose.yml file, which is generated if a DB driver is used.
2 | The Dockerfile includes a two-stage build, and the final config depends on the use of advanced features. In the end, you will have a smaller image without unnecessary build dependencies.
3 |
4 | ## Dockerfile
5 |
6 | ```dockerfile
7 | FROM golang:1.24.4-alpine AS build
8 |
9 | RUN apk add --no-cache curl libstdc++ libgcc
10 |
11 | WORKDIR /app
12 |
13 | COPY go.mod go.sum ./
14 | RUN go mod download
15 |
16 | COPY . .
17 |
18 | RUN go install github.com/a-h/templ/cmd/templ@latest && \
19 | templ generate && \
20 | curl -sL https://github.com/tailwindlabs/tailwindcss/releases/latest/download/tailwindcss-linux-x64-musl -o tailwindcss && \
21 | chmod +x tailwindcss && \
22 | ./tailwindcss -i cmd/web/styles/input.css -o cmd/web/assets/css/output.css
23 |
24 | RUN go build -o main cmd/api/main.go
25 |
26 | FROM alpine:3.20.1 AS prod
27 | WORKDIR /app
28 | COPY --from=build /app/main /app/main
29 | EXPOSE ${PORT}
30 | CMD ["./main"]
31 | ```
32 |
33 | Docker config if React flag is used:
34 |
35 | ```dockerfile
36 | FROM golang:1.24.4-alpine AS build
37 |
38 | WORKDIR /app
39 |
40 | COPY go.mod go.sum ./
41 | RUN go mod download
42 |
43 | COPY . .
44 |
45 | RUN go build -o main cmd/api/main.go
46 |
47 | FROM alpine:3.20.1 AS prod
48 | WORKDIR /app
49 | COPY --from=build /app/main /app/main
50 | EXPOSE ${PORT}
51 | CMD ["./main"]
52 |
53 |
54 | FROM node:20 AS frontend_builder
55 | WORKDIR /frontend
56 |
57 | COPY frontend/package*.json ./
58 | RUN npm install
59 | COPY frontend/. .
60 | RUN npm run build
61 |
62 | FROM node:20-slim AS frontend
63 | RUN npm install -g serve
64 | COPY --from=frontend_builder /frontend/dist /app/dist
65 | EXPOSE 5173
66 | CMD ["serve", "-s", "/app/dist", "-l", "5173"]
67 | ```
68 | ## Docker compose
69 | Docker and docker-compose.yml pull environment variables from the .env file.
70 |
71 | Example if the Docker flag is used with the MySQL DB driver:
72 | ```yaml
73 | services:
74 | app:
75 | build:
76 | context: .
77 | dockerfile: Dockerfile
78 | target: prod
79 | restart: unless-stopped
80 | ports:
81 | - ${PORT}:${PORT}
82 | environment:
83 | APP_ENV: ${APP_ENV}
84 | PORT: ${PORT}
85 | BLUEPRINT_DB_HOST: ${BLUEPRINT_DB_HOST}
86 | BLUEPRINT_DB_PORT: ${BLUEPRINT_DB_PORT}
87 | BLUEPRINT_DB_DATABASE: ${BLUEPRINT_DB_DATABASE}
88 | BLUEPRINT_DB_USERNAME: ${BLUEPRINT_DB_USERNAME}
89 | BLUEPRINT_DB_PASSWORD: ${BLUEPRINT_DB_PASSWORD}
90 | depends_on:
91 | mysql_bp:
92 | condition: service_healthy
93 | networks:
94 | - blueprint
95 | mysql_bp:
96 | image: mysql:latest
97 | restart: unless-stopped
98 | environment:
99 | MYSQL_DATABASE: ${BLUEPRINT_DB_DATABASE}
100 | MYSQL_USER: ${BLUEPRINT_DB_USERNAME}
101 | MYSQL_PASSWORD: ${BLUEPRINT_DB_PASSWORD}
102 | MYSQL_ROOT_PASSWORD: ${BLUEPRINT_DB_ROOT_PASSWORD}
103 | ports:
104 | - "${BLUEPRINT_DB_PORT}:3306"
105 | volumes:
106 | - mysql_volume_bp:/var/lib/mysql
107 | healthcheck:
108 | test: ["CMD", "mysqladmin", "ping", "-h", "${BLUEPRINT_DB_HOST}", "-u", "${BLUEPRINT_DB_USERNAME}", "--password=${BLUEPRINT_DB_PASSWORD}"]
109 | interval: 5s
110 | timeout: 5s
111 | retries: 3
112 | start_period: 15s
113 | networks:
114 | - blueprint
115 |
116 | volumes:
117 | mysql_volume_bp:
118 | networks:
119 | blueprint:
120 | ```
121 |
122 | ## Note
123 | If you are testing more than one framework locally, be aware of Docker leftovers such as volumes.
124 | For proper cleaning and building, use `docker compose down --volumes` and `docker compose up --build`.
125 |
126 | or
127 |
128 | ```bash
129 | docker compose build --no-cache && docker compose up
130 | ```
131 |
--------------------------------------------------------------------------------
/cmd/ui/multiInput/multiInput.go:
--------------------------------------------------------------------------------
1 | // Package multiInput provides functions that
2 | // help define and draw a multi-input step
3 | package multiInput
4 |
5 | import (
6 | "fmt"
7 |
8 | "github.com/melkeydev/go-blueprint/cmd/program"
9 | "github.com/melkeydev/go-blueprint/cmd/steps"
10 |
11 | tea "github.com/charmbracelet/bubbletea"
12 | "github.com/charmbracelet/lipgloss"
13 | )
14 |
15 | // Change this
16 | var (
17 | focusedStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("#01FAC6")).Bold(true)
18 | titleStyle = lipgloss.NewStyle().Background(lipgloss.Color("#01FAC6")).Foreground(lipgloss.Color("#030303")).Bold(true).Padding(0, 1, 0)
19 | selectedItemStyle = lipgloss.NewStyle().PaddingLeft(1).Foreground(lipgloss.Color("170")).Bold(true)
20 | selectedItemDescStyle = lipgloss.NewStyle().PaddingLeft(1).Foreground(lipgloss.Color("170"))
21 | descriptionStyle = lipgloss.NewStyle().Foreground(lipgloss.Color("#40BDA3"))
22 | )
23 |
24 | // A Selection represents a choice made in a multiInput step
25 | type Selection struct {
26 | Choice string
27 | }
28 |
29 | // Update changes the value of a Selection's Choice
30 | func (s *Selection) Update(value string) {
31 | s.Choice = value
32 | }
33 |
34 | // A multiInput.model contains the data for the multiInput step.
35 | //
36 | // It has the required methods that make it a bubbletea.Model
37 | type model struct {
38 | cursor int
39 | choices []steps.Item
40 | selected map[int]struct{}
41 | choice *Selection
42 | header string
43 | exit *bool
44 | }
45 |
46 | func (m model) Init() tea.Cmd {
47 | return nil
48 | }
49 |
50 | // InitialModelMulti initializes a multiInput step with
51 | // the given data
52 | func InitialModelMulti(choices []steps.Item, selection *Selection, header string, program *program.Project) model {
53 | return model{
54 | choices: choices,
55 | selected: make(map[int]struct{}),
56 | choice: selection,
57 | header: titleStyle.Render(header),
58 | exit: &program.Exit,
59 | }
60 | }
61 |
62 | // Update is called when "things happen", it checks for
63 | // important keystrokes to signal when to quit, change selection,
64 | // and confirm the selection.
65 | func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
66 | switch msg := msg.(type) {
67 | case tea.KeyMsg:
68 | switch msg.String() {
69 | case "ctrl+c", "q":
70 | *m.exit = true
71 | return m, tea.Quit
72 | case "up", "k":
73 | if m.cursor > 0 {
74 | m.cursor--
75 | }
76 | case "down", "j":
77 | if m.cursor < len(m.choices)-1 {
78 | m.cursor++
79 | }
80 | case "enter", " ":
81 | if len(m.selected) == 1 {
82 | m.selected = make(map[int]struct{})
83 | }
84 | _, ok := m.selected[m.cursor]
85 | if ok {
86 | delete(m.selected, m.cursor)
87 | } else {
88 | m.selected[m.cursor] = struct{}{}
89 | }
90 | case "y":
91 | if len(m.selected) == 1 {
92 | for selectedKey := range m.selected {
93 | m.choice.Update(m.choices[selectedKey].Title)
94 | m.cursor = selectedKey
95 | }
96 | return m, tea.Quit
97 | }
98 | }
99 | }
100 | return m, nil
101 | }
102 |
103 | // View is called to draw the multiInput step
104 | func (m model) View() string {
105 | s := m.header + "\n\n"
106 |
107 | for i, choice := range m.choices {
108 | cursor := " "
109 | if m.cursor == i {
110 | cursor = focusedStyle.Render(">")
111 | choice.Title = selectedItemStyle.Render(choice.Title)
112 | choice.Desc = selectedItemDescStyle.Render(choice.Desc)
113 | }
114 |
115 | checked := " "
116 | if _, ok := m.selected[i]; ok {
117 | checked = focusedStyle.Render("x")
118 | }
119 |
120 | title := focusedStyle.Render(choice.Title)
121 | description := descriptionStyle.Render(choice.Desc)
122 |
123 | s += fmt.Sprintf("%s [%s] %s\n%s\n\n", cursor, checked, title, description)
124 | }
125 |
126 | s += fmt.Sprintf("Press %s to confirm choice.\n\n", focusedStyle.Render("y"))
127 | return s
128 | }
129 |
--------------------------------------------------------------------------------
/cmd/template/dbdriver/files/service/postgres.tmpl:
--------------------------------------------------------------------------------
1 | package database
2 |
3 | import (
4 | "context"
5 | "database/sql"
6 | "fmt"
7 | "log"
8 | "os"
9 | "strconv"
10 | "time"
11 |
12 | _ "github.com/jackc/pgx/v5/stdlib"
13 | _ "github.com/joho/godotenv/autoload"
14 | )
15 |
16 | // Service represents a service that interacts with a database.
17 | type Service interface {
18 | // Health returns a map of health status information.
19 | // The keys and values in the map are service-specific.
20 | Health() map[string]string
21 |
22 | // Close terminates the database connection.
23 | // It returns an error if the connection cannot be closed.
24 | Close() error
25 | }
26 |
27 | type service struct {
28 | db *sql.DB
29 | }
30 |
31 | var (
32 | database = os.Getenv("BLUEPRINT_DB_DATABASE")
33 | password = os.Getenv("BLUEPRINT_DB_PASSWORD")
34 | username = os.Getenv("BLUEPRINT_DB_USERNAME")
35 | port = os.Getenv("BLUEPRINT_DB_PORT")
36 | host = os.Getenv("BLUEPRINT_DB_HOST")
37 | schema = os.Getenv("BLUEPRINT_DB_SCHEMA")
38 | dbInstance *service
39 | )
40 |
41 | func New() Service {
42 | // Reuse Connection
43 | if dbInstance != nil {
44 | return dbInstance
45 | }
46 | connStr := fmt.Sprintf("postgres://%s:%s@%s:%s/%s?sslmode=disable&search_path=%s", username, password, host, port, database, schema)
47 | db, err := sql.Open("pgx", connStr)
48 | if err != nil {
49 | log.Fatal(err)
50 | }
51 | dbInstance = &service{
52 | db: db,
53 | }
54 | return dbInstance
55 | }
56 |
57 | // Health checks the health of the database connection by pinging the database.
58 | // It returns a map with keys indicating various health statistics.
59 | func (s *service) Health() map[string]string {
60 | ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
61 | defer cancel()
62 |
63 | stats := make(map[string]string)
64 |
65 | // Ping the database
66 | err := s.db.PingContext(ctx)
67 | if err != nil {
68 | stats["status"] = "down"
69 | stats["error"] = fmt.Sprintf("db down: %v", err)
70 | log.Fatalf("db down: %v", err) // Log the error and terminate the program
71 | return stats
72 | }
73 |
74 | // Database is up, add more statistics
75 | stats["status"] = "up"
76 | stats["message"] = "It's healthy"
77 |
78 | // Get database stats (like open connections, in use, idle, etc.)
79 | dbStats := s.db.Stats()
80 | stats["open_connections"] = strconv.Itoa(dbStats.OpenConnections)
81 | stats["in_use"] = strconv.Itoa(dbStats.InUse)
82 | stats["idle"] = strconv.Itoa(dbStats.Idle)
83 | stats["wait_count"] = strconv.FormatInt(dbStats.WaitCount, 10)
84 | stats["wait_duration"] = dbStats.WaitDuration.String()
85 | stats["max_idle_closed"] = strconv.FormatInt(dbStats.MaxIdleClosed, 10)
86 | stats["max_lifetime_closed"] = strconv.FormatInt(dbStats.MaxLifetimeClosed, 10)
87 |
88 | // Evaluate stats to provide a health message
89 | if dbStats.OpenConnections > 40 { // Assuming 50 is the max for this example
90 | stats["message"] = "The database is experiencing heavy load."
91 | }
92 |
93 | if dbStats.WaitCount > 1000 {
94 | stats["message"] = "The database has a high number of wait events, indicating potential bottlenecks."
95 | }
96 |
97 | if dbStats.MaxIdleClosed > int64(dbStats.OpenConnections)/2 {
98 | stats["message"] = "Many idle connections are being closed, consider revising the connection pool settings."
99 | }
100 |
101 | if dbStats.MaxLifetimeClosed > int64(dbStats.OpenConnections)/2 {
102 | stats["message"] = "Many connections are being closed due to max lifetime, consider increasing max lifetime or revising the connection usage pattern."
103 | }
104 |
105 | return stats
106 | }
107 |
108 | // Close closes the database connection.
109 | // It logs a message indicating the disconnection from the specific database.
110 | // If the connection is successfully closed, it returns nil.
111 | // If an error occurs while closing the connection, it returns the error.
112 | func (s *service) Close() error {
113 | log.Printf("Disconnected from database: %s", database)
114 | return s.db.Close()
115 | }
116 |
--------------------------------------------------------------------------------
/cmd/template/dbdriver/files/service/mysql.tmpl:
--------------------------------------------------------------------------------
1 | package database
2 |
3 | import (
4 | "context"
5 | "database/sql"
6 | "fmt"
7 | "log"
8 | "os"
9 | "strconv"
10 | "time"
11 |
12 | _ "github.com/go-sql-driver/mysql"
13 | _ "github.com/joho/godotenv/autoload"
14 | )
15 |
16 | // Service represents a service that interacts with a database.
17 | type Service interface {
18 | // Health returns a map of health status information.
19 | // The keys and values in the map are service-specific.
20 | Health() map[string]string
21 |
22 | // Close terminates the database connection.
23 | // It returns an error if the connection cannot be closed.
24 | Close() error
25 | }
26 |
27 | type service struct {
28 | db *sql.DB
29 | }
30 |
31 | var (
32 | dbname = os.Getenv("BLUEPRINT_DB_DATABASE")
33 | password = os.Getenv("BLUEPRINT_DB_PASSWORD")
34 | username = os.Getenv("BLUEPRINT_DB_USERNAME")
35 | port = os.Getenv("BLUEPRINT_DB_PORT")
36 | host = os.Getenv("BLUEPRINT_DB_HOST")
37 | dbInstance *service
38 | )
39 |
40 | func New() Service {
41 | // Reuse Connection
42 | if dbInstance != nil {
43 | return dbInstance
44 | }
45 |
46 | // Opening a driver typically will not attempt to connect to the database.
47 | db, err := sql.Open("mysql", fmt.Sprintf("%s:%s@tcp(%s:%s)/%s", username, password, host, port, dbname))
48 | if err != nil {
49 | // This will not be a connection error, but a DSN parse error or
50 | // another initialization error.
51 | log.Fatal(err)
52 | }
53 | db.SetConnMaxLifetime(0)
54 | db.SetMaxIdleConns(50)
55 | db.SetMaxOpenConns(50)
56 |
57 | dbInstance = &service{
58 | db: db,
59 | }
60 | return dbInstance
61 | }
62 |
63 | // Health checks the health of the database connection by pinging the database.
64 | // It returns a map with keys indicating various health statistics.
65 | func (s *service) Health() map[string]string {
66 | ctx, cancel := context.WithTimeout(context.Background(), 1*time.Second)
67 | defer cancel()
68 |
69 | stats := make(map[string]string)
70 |
71 | // Ping the database
72 | err := s.db.PingContext(ctx)
73 | if err != nil {
74 | stats["status"] = "down"
75 | stats["error"] = fmt.Sprintf("db down: %v", err)
76 | log.Fatalf("db down: %v", err) // Log the error and terminate the program
77 | return stats
78 | }
79 |
80 | // Database is up, add more statistics
81 | stats["status"] = "up"
82 | stats["message"] = "It's healthy"
83 |
84 | // Get database stats (like open connections, in use, idle, etc.)
85 | dbStats := s.db.Stats()
86 | stats["open_connections"] = strconv.Itoa(dbStats.OpenConnections)
87 | stats["in_use"] = strconv.Itoa(dbStats.InUse)
88 | stats["idle"] = strconv.Itoa(dbStats.Idle)
89 | stats["wait_count"] = strconv.FormatInt(dbStats.WaitCount, 10)
90 | stats["wait_duration"] = dbStats.WaitDuration.String()
91 | stats["max_idle_closed"] = strconv.FormatInt(dbStats.MaxIdleClosed, 10)
92 | stats["max_lifetime_closed"] = strconv.FormatInt(dbStats.MaxLifetimeClosed, 10)
93 |
94 | // Evaluate stats to provide a health message
95 | if dbStats.OpenConnections > 40 { // Assuming 50 is the max for this example
96 | stats["message"] = "The database is experiencing heavy load."
97 | }
98 | if dbStats.WaitCount > 1000 {
99 | stats["message"] = "The database has a high number of wait events, indicating potential bottlenecks."
100 | }
101 |
102 | if dbStats.MaxIdleClosed > int64(dbStats.OpenConnections)/2 {
103 | stats["message"] = "Many idle connections are being closed, consider revising the connection pool settings."
104 | }
105 |
106 | if dbStats.MaxLifetimeClosed > int64(dbStats.OpenConnections)/2 {
107 | stats["message"] = "Many connections are being closed due to max lifetime, consider increasing max lifetime or revising the connection usage pattern."
108 | }
109 |
110 | return stats
111 | }
112 |
113 | // Close closes the database connection.
114 | // It logs a message indicating the disconnection from the specific database.
115 | // If the connection is successfully closed, it returns nil.
116 | // If an error occurs while closing the connection, it returns the error.
117 | func (s *service) Close() error {
118 | log.Printf("Disconnected from database: %s", dbname)
119 | return s.db.Close()
120 | }
121 |
--------------------------------------------------------------------------------
/cmd/template/advanced/routes.go:
--------------------------------------------------------------------------------
1 | package advanced
2 |
3 | import (
4 | _ "embed"
5 | )
6 |
7 | //go:embed files/htmx/hello.templ.tmpl
8 | var helloTemplTemplate []byte
9 |
10 | //go:embed files/htmx/base.templ.tmpl
11 | var baseTemplTemplate []byte
12 |
13 | //go:embed files/react/tailwind/index.css.tmpl
14 | var inputCssTemplateReact []byte
15 |
16 | //go:embed files/react/tailwind/vite.config.ts.tmpl
17 | var viteTailwindConfigFile []byte
18 |
19 | //go:embed files/react/tailwind/app.tsx.tmpl
20 | var reactTailwindAppFile []byte
21 |
22 | //go:embed files/react/app.tsx.tmpl
23 | var reactAppFile []byte
24 |
25 | //go:embed files/tailwind/input.css.tmpl
26 | var inputCssTemplate []byte
27 |
28 | //go:embed files/tailwind/output.css.tmpl
29 | var outputCssTemplate []byte
30 |
31 | //go:embed files/htmx/tailwind/tailwind.config.js.tmpl
32 | var htmxTailwindConfigJsTemplate []byte
33 |
34 | //go:embed files/htmx/htmx.min.js.tmpl
35 | var htmxMinJsTemplate []byte
36 |
37 | //go:embed files/htmx/efs.go.tmpl
38 | var efsTemplate []byte
39 |
40 | //go:embed files/htmx/hello.go.tmpl
41 | var helloGoTemplate []byte
42 |
43 | //go:embed files/htmx/hello_fiber.go.tmpl
44 | var helloFiberGoTemplate []byte
45 |
46 | //go:embed files/htmx/routes/http_router.tmpl
47 | var httpRouterHtmxTemplRoutes []byte
48 |
49 | //go:embed files/htmx/routes/standard_library.tmpl
50 | var stdLibHtmxTemplRoutes []byte
51 |
52 | //go:embed files/htmx/imports/standard_library.tmpl
53 | var stdLibHtmxTemplImports []byte
54 |
55 | //go:embed files/websocket/imports/standard_library.tmpl
56 | var stdLibWebsocketImports []byte
57 |
58 | //go:embed files/htmx/routes/chi.tmpl
59 | var chiHtmxTemplRoutes []byte
60 |
61 | //go:embed files/htmx/routes/gin.tmpl
62 | var ginHtmxTemplRoutes []byte
63 |
64 | //go:embed files/htmx/imports/gin.tmpl
65 | var ginHtmxTemplImports []byte
66 |
67 | //go:embed files/htmx/routes/gorilla.tmpl
68 | var gorillaHtmxTemplRoutes []byte
69 |
70 | //go:embed files/htmx/routes/echo.tmpl
71 | var echoHtmxTemplRoutes []byte
72 |
73 | //go:embed files/htmx/routes/fiber.tmpl
74 | var fiberHtmxTemplRoutes []byte
75 |
76 | //go:embed files/htmx/imports/fiber.tmpl
77 | var fiberHtmxTemplImports []byte
78 |
79 | //go:embed files/websocket/imports/fiber.tmpl
80 | var fiberWebsocketTemplImports []byte
81 |
82 | func EchoHtmxTemplRoutesTemplate() []byte {
83 | return echoHtmxTemplRoutes
84 | }
85 |
86 | func GorillaHtmxTemplRoutesTemplate() []byte {
87 | return gorillaHtmxTemplRoutes
88 | }
89 |
90 | func ChiHtmxTemplRoutesTemplate() []byte {
91 | return chiHtmxTemplRoutes
92 | }
93 |
94 | func GinHtmxTemplRoutesTemplate() []byte {
95 | return ginHtmxTemplRoutes
96 | }
97 |
98 | func HttpRouterHtmxTemplRoutesTemplate() []byte {
99 | return httpRouterHtmxTemplRoutes
100 | }
101 |
102 | func StdLibHtmxTemplRoutesTemplate() []byte {
103 | return stdLibHtmxTemplRoutes
104 | }
105 |
106 | func StdLibHtmxTemplImportsTemplate() []byte {
107 | return stdLibHtmxTemplImports
108 | }
109 |
110 | func StdLibWebsocketTemplImportsTemplate() []byte {
111 | return stdLibWebsocketImports
112 | }
113 |
114 | func HelloTemplTemplate() []byte {
115 | return helloTemplTemplate
116 | }
117 |
118 | func BaseTemplTemplate() []byte {
119 | return baseTemplTemplate
120 | }
121 |
122 | func ReactTailwindAppfile() []byte {
123 | return reactTailwindAppFile
124 | }
125 |
126 | func ReactAppfile() []byte {
127 | return reactAppFile
128 | }
129 |
130 | func InputCssTemplateReact() []byte {
131 | return inputCssTemplateReact
132 | }
133 |
134 | func ViteTailwindConfigFile() []byte {
135 | return viteTailwindConfigFile
136 | }
137 |
138 | func InputCssTemplate() []byte {
139 | return inputCssTemplate
140 | }
141 |
142 | func OutputCssTemplate() []byte {
143 | return outputCssTemplate
144 | }
145 |
146 | func HtmxTailwindConfigJsTemplate() []byte {
147 | return htmxTailwindConfigJsTemplate
148 | }
149 |
150 | func HtmxJSTemplate() []byte {
151 | return htmxMinJsTemplate
152 | }
153 |
154 | func EfsTemplate() []byte {
155 | return efsTemplate
156 | }
157 |
158 | func HelloGoTemplate() []byte {
159 | return helloGoTemplate
160 | }
161 |
162 | func HelloFiberGoTemplate() []byte {
163 | return helloFiberGoTemplate
164 | }
165 |
166 | func FiberHtmxTemplRoutesTemplate() []byte {
167 | return fiberHtmxTemplRoutes
168 | }
169 |
170 | func FiberHtmxTemplImportsTemplate() []byte {
171 | return fiberHtmxTemplImports
172 | }
173 |
174 | func FiberWebsocketTemplImportsTemplate() []byte {
175 | return fiberWebsocketTemplImports
176 | }
177 |
178 | func GinHtmxTemplImportsTemplate() []byte {
179 | return ginHtmxTemplImports
180 | }
181 |
--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
1 | github.com/atotto/clipboard v0.1.4 h1:EH0zSVneZPSuFR11BlR9YppQTVDbh5+16AmcJi4g1z4=
2 | github.com/atotto/clipboard v0.1.4/go.mod h1:ZY9tmq7sm5xIbd9bOK4onWV4S6X0u6GY7Vn0Yu86PYI=
3 | github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
4 | github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
5 | github.com/charmbracelet/bubbles v0.16.1 h1:6uzpAAaT9ZqKssntbvZMlksWHruQLNxg49H5WdeuYSY=
6 | github.com/charmbracelet/bubbles v0.16.1/go.mod h1:2QCp9LFlEsBQMvIYERr7Ww2H2bA7xen1idUDIzm/+Xc=
7 | github.com/charmbracelet/bubbletea v0.24.2 h1:uaQIKx9Ai6Gdh5zpTbGiWpytMU+CfsPp06RaW2cx/SY=
8 | github.com/charmbracelet/bubbletea v0.24.2/go.mod h1:XdrNrV4J8GiyshTtx3DNuYkR1FDaJmO3l2nejekbsgg=
9 | github.com/charmbracelet/lipgloss v0.9.0 h1:BHIM7U4vX77xGEld8GrTKspBMtSv7j0wxPCH73nrdxE=
10 | github.com/charmbracelet/lipgloss v0.9.0/go.mod h1:h8KDyaivONasw1Bhb4nWiKlk4P1wHPly+3+3v6EFMmA=
11 | github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81 h1:q2hJAaP1k2wIvVRd/hEHD7lacgqrCPS+k8g1MndzfWY=
12 | github.com/containerd/console v1.0.4-0.20230313162750-1ae8d489ac81/go.mod h1:YynlIjWYF8myEu6sdkwKIvGQq+cOckRm6So2avqoYAk=
13 | github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
14 | github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
15 | github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
16 | github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
17 | github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
18 | github.com/mattn/go-isatty v0.0.18 h1:DOKFKCQ7FNG2L1rbrmstDN4QVRdS89Nkh85u68Uwp98=
19 | github.com/mattn/go-isatty v0.0.18/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
20 | github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
21 | github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
22 | github.com/mattn/go-runewidth v0.0.12/go.mod h1:RAqKPSqVFrSLVXbA8x7dzmKdmGzieGRCM46jaSJTDAk=
23 | github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
24 | github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
25 | github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b h1:1XF24mVaiu7u+CFywTdcDo2ie1pzzhwjt6RHqzpMU34=
26 | github.com/muesli/ansi v0.0.0-20211018074035-2e021307bc4b/go.mod h1:fQuZ0gauxyBcmsdE3ZT4NasjaRdxmbCS0jRHsrWu3Ho=
27 | github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
28 | github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
29 | github.com/muesli/reflow v0.3.0 h1:IFsN6K9NfGtjeggFP+68I4chLZV2yIKsXJFNZ+eWh6s=
30 | github.com/muesli/reflow v0.3.0/go.mod h1:pbwTDkVPibjO2kyvBQRBxTWEEGDGq0FlB1BIKtnHY/8=
31 | github.com/muesli/termenv v0.15.2 h1:GohcuySI0QmI3wN8Ok9PtKGkgkFIk7y6Vpb5PvrY+Wo=
32 | github.com/muesli/termenv v0.15.2/go.mod h1:Epx+iuz8sNs7mNKhxzH4fWXGNpZwUaJKRS1noLXviQ8=
33 | github.com/rivo/uniseg v0.1.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
34 | github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
35 | github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
36 | github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
37 | github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
38 | github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
39 | github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
40 | github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
41 | golang.org/x/sync v0.1.0 h1:wsuoTGHzEhffawBOhz5CYhcrV4IdKZbEyZjBMuTp12o=
42 | golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
43 | golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
44 | golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
45 | golang.org/x/sys v0.12.0 h1:CM0HF96J0hcLAwsHPJZjfdNzs0gftsLfgKt57wWHJ0o=
46 | golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
47 | golang.org/x/term v0.6.0 h1:clScbb1cHjoCkyRbWwBEUZ5H/tIFu5TAXIqaZD0Gcjw=
48 | golang.org/x/term v0.6.0/go.mod h1:m6U89DPEgQRMq3DNkDClhWw02AUbt2daBVO4cn4Hv9U=
49 | golang.org/x/text v0.3.8 h1:nAL+RVCQ9uMn3vJZbV+MRnydTJFPf8qqY42YiA6MrqY=
50 | golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
51 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
52 | gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
53 |
--------------------------------------------------------------------------------
/cmd/steps/steps.go:
--------------------------------------------------------------------------------
1 | // Package steps provides utility for creating
2 | // each step of the CLI
3 | package steps
4 |
5 | import "github.com/melkeydev/go-blueprint/cmd/flags"
6 |
7 | // A StepSchema contains the data that is used
8 | // for an individual step of the CLI
9 | type StepSchema struct {
10 | StepName string // The name of a given step
11 | Options []Item // The slice of each option for a given step
12 | Headers string // The title displayed at the top of a given step
13 | Field string
14 | }
15 |
16 | // Steps contains a slice of steps
17 | type Steps struct {
18 | Steps map[string]StepSchema
19 | }
20 |
21 | // An Item contains the data for each option
22 | // in a StepSchema.Options
23 | type Item struct {
24 | Flag, Title, Desc string
25 | }
26 |
27 | // InitSteps initializes and returns the *Steps to be used in the CLI program
28 | func InitSteps(projectType flags.Framework, databaseType flags.Database) *Steps {
29 | steps := &Steps{
30 | map[string]StepSchema{
31 | "framework": {
32 | StepName: "Go Project Framework",
33 | Options: []Item{
34 | {
35 | Title: "Standard-library",
36 | Desc: "The built-in Go standard library HTTP package",
37 | },
38 | {
39 | Title: "Chi",
40 | Desc: "A lightweight, idiomatic and composable router for building Go HTTP services",
41 | },
42 | {
43 | Title: "Gin",
44 | Desc: "Features a martini-like API with performance that is up to 40 times faster thanks to httprouter",
45 | },
46 | {
47 | Title: "Fiber",
48 | Desc: "An Express inspired web framework built on top of Fasthttp",
49 | },
50 | {
51 | Title: "Gorilla/Mux",
52 | Desc: "Package gorilla/mux implements a request router and dispatcher for matching incoming requests to their respective handler",
53 | },
54 | {
55 | Title: "HttpRouter",
56 | Desc: "HttpRouter is a lightweight high performance HTTP request router for Go",
57 | },
58 | {
59 | Title: "Echo",
60 | Desc: "High performance, extensible, minimalist Go web framework",
61 | },
62 | },
63 | Headers: "What framework do you want to use in your Go project?",
64 | Field: projectType.String(),
65 | },
66 | "driver": {
67 | StepName: "Go Project Database Driver",
68 | Options: []Item{
69 | {
70 | Title: "Mysql",
71 | Desc: "MySQL-Driver for Go's database/sql package",
72 | },
73 | {
74 | Title: "Postgres",
75 | Desc: "Go postgres driver for Go's database/sql package"},
76 | {
77 | Title: "Sqlite",
78 | Desc: "sqlite3 driver conforming to the built-in database/sql interface"},
79 | {
80 | Title: "Mongo",
81 | Desc: "The MongoDB supported driver for Go."},
82 | {
83 | Title: "Redis",
84 | Desc: "Redis driver for Go."},
85 | {
86 | Title: "Scylla",
87 | Desc: "ScyllaDB Enhanced driver from GoCQL."},
88 | {
89 | Title: "None",
90 | Desc: "Choose this option if you don't wish to install a specific database driver."},
91 | },
92 | Headers: "What database driver do you want to use in your Go project?",
93 | Field: databaseType.String(),
94 | },
95 | "advanced": {
96 | StepName: "Advanced Features",
97 | Headers: "Which advanced features do you want?",
98 | Options: []Item{
99 | {
100 | Flag: "React",
101 | Title: "React",
102 | Desc: "Use Vite to spin up a React project in TypeScript. This disables selecting HTMX/Templ",
103 | },
104 | {
105 | Flag: "Htmx",
106 | Title: "HTMX/Templ",
107 | Desc: "Add starter HTMX and Templ files. This disables selecting React",
108 | },
109 | {
110 | Flag: "GitHubAction",
111 | Title: "Go Project Workflow",
112 | Desc: "Workflow templates for testing, cross-compiling and releasing Go projects",
113 | },
114 | {
115 | Flag: "Websocket",
116 | Title: "Websocket endpoint",
117 | Desc: "Add a websocket endpoint",
118 | },
119 | {
120 | Flag: "Tailwind",
121 | Title: "TailwindCSS",
122 | Desc: "A utility-first CSS framework (selecting this will automatically add HTMX unless React is specified)",
123 | },
124 | {
125 | Flag: "Docker",
126 | Title: "Docker",
127 | Desc: "Dockerfile and docker-compose generic configuration for go project",
128 | },
129 | },
130 | },
131 | "git": {
132 | StepName: "Git Repository",
133 | Headers: "Which git option would you like to select for your project?",
134 | Options: []Item{
135 | {
136 | Title: "Commit",
137 | Desc: "Initialize a new git repository and commit all the changes",
138 | },
139 | {
140 | Title: "Stage",
141 | Desc: "Initialize a new git repository but only stage the changes",
142 | },
143 | {
144 | Title: "Skip",
145 | Desc: "Proceed without initializing a git repository",
146 | },
147 | },
148 | },
149 | },
150 | }
151 |
152 | return steps
153 | }
154 |
--------------------------------------------------------------------------------
17 |
55 |
18 |
25 |
26 | 19 | Welcome to Vite + React 20 |
21 |
22 | Get started by editing src/App.tsx
23 |
27 |
50 |
51 |
28 |
34 |
35 |
41 |
42 | {message && (
43 |
49 |
44 |
47 | )}
48 | Server Response:
45 |{message}
46 |
52 | Built with Vite, React, and Tailwind CSS
53 |
54 |