Adventure: Building with NATS Jetstream KV Store -Part 6

# Create the project
$  mkdir $HOME/Projects/ds_nats_ttt

# cd into our project
$  cd $HOME/Projects/ds_nats_ttt

# Initialize a Go module
$  go mod init github.com//ds_nats_ttt

# Initialize a Git repository
$  git init

# Create our folder structure
$  mkdir -p cmd/web internal/routes ui/layouts ui/pages ui/static ui/styles

# Create our files
$  touch cmd/web/main.go
$  touch internal/routes/index.go internal/routes/router.go
$  touch ui/layouts/base.templ ui/pages/index.templ ui/styles/styles.css

ds_nats_ttt/                  # Project root
│── cmd/                      # Application entry points
│   ├── web/                  # Web application
│   │   ├── main.go           # Web server entry point
│
│── internal/                  # Internal application logic (not accessible externally)
│   ├── routes/                # Route handling logic
│   │   ├── index.go           # Index/home route logic
│   │   ├── router.go          # Router setup
│
│── ui/                        # User interface assets
│   ├── layouts/               # Layout templates (shared layouts)
│   │   ├── base.templ         # Base layout template (e.g., HTML boilerplate)
│   ├── pages/                 # Page-specific templates
│   │   ├── index.templ        # Index page template
│   ├── static/                # Static files (CSS, JS, images)
|    
│   ├── styles/                # Tailwind CSS Baseline
│   │   ├── styles.css         # Index page template

replace github.com//ds_nats_ttt/internal/routes => /home/.../Projects/ds_nats_ttt/internal/routes

replace github.com//ds_nats_ttt/ui/layouts => /home/.../Projects/ds_nats_ttt/ui/layouts

replace github.com//ds_nats_ttt/ui/pages => /home/.../Projects/ds_nats_ttt/ui/pages

package main

import (
 "context"
 "fmt"
 "log/slog"
 "net/http"
 "os"
 "os/signal"
 "syscall"

 "github.com/rphumulock/ds_nats_ttt/internal/routes"

 "github.com/go-chi/chi/v5"
 "github.com/go-chi/chi/v5/middleware"
 "golang.org/x/sync/errgroup"
)

func main() {

 // Logger Setup – Creates a structured JSON logger (slog) for logging events.
 logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))

 // Port Configuration – Checks for a PORT environment variable; 
 // defaults to 8080 if not set.
 getPort := func() string {
  if p, ok := os.LookupEnv("PORT"); ok {
   return p
  }
  return "8080"
 }

 // Signal Handling – Uses signal.NotifyContext to listen for termination 
 // signals (SIGINT, SIGTERM), ensuring the server shuts down cleanly when 
 // interrupted.
 logger.Info(fmt.Sprintf("Starting Server 0.0.0.0:%s", getPort()))
 defer logger.Info("Stopping Server")

 // Start Server – Calls run() to launch the server, passing the 
 // execution context, logger, and port.
 ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
 defer stop()

 // Error Handling – If run() fails, it logs the error and exits the 
 // program with a non-zero status.
 if err := run(ctx, logger, getPort()); err != nil {
  logger.Error("Error running server", slog.Any("err", err))
  os.Exit(1)
 }
}

// This function ensures the server runs in a controlled environment, 
// handles errors properly, and stops all goroutines when needed.
func run(ctx context.Context, logger *slog.Logger, port string) error {

 // Create an Error Group – Uses errgroup.WithContext to manage 
 // multiple goroutines, ensuring errors propagate properly.
 g, ctx := errgroup.WithContext(ctx)

 // Start the Server – Calls startServer() within a new goroutine so it 
 // runs concurrently.
 g.Go(startServer(ctx, logger, port))

 // Wait for Completion – g.Wait() blocks until all goroutines finish 
 // or one returns an error.
 if err := g.Wait(); err != nil {
  return fmt.Errorf("error running server: %w", err)
 }

 return nil
}

// This function ensures the server runs properly with logging, 
// structured routing, and a clean shutdown process.
func startServer(ctx context.Context, logger *slog.Logger, port string) func() error {
 return func() error {
  router := chi.NewMux()

  // Router Setup - Creates a new Chi router and applies middleware 
  // for logging and panic recovery.
  router.Use(
   middleware.Logger,
   middleware.Recoverer,
  )

  // Static File Handling - Configures the server to serve static files 
  // from the ./static directory.
  router.Handle("/static/*", http.StripPrefix("/static/", http.FileServer(http.Dir("./ui/static"))))

  // Route Initialization - Calls SetupRoutes() to register application 
  // routes. If route setup fails, it returns an error. A cleanup function 
  // is deferred to release resources when the server shuts down.
  cleanup, err := routes.SetupRoutes(ctx, logger, router)
  defer cleanup()
  if err != nil {
   return fmt.Errorf("error setting up routes: %w", err)
  }

  // Server Configuration - Creates an HTTP server that listens on 
  // 0.0.0.0: and uses the configured router.
  srv := &http.Server{
   Addr:    "0.0.0.0:" + port,
   Handler: router,
  }

  // Graceful Shutdown - Runs a goroutine that waits for a shutdown 
  // signal (ctx.Done()) and shuts down the server when triggered.
  go func() {
   <-ctx.Done()
   srv.Shutdown(context.Background())
  }()

  return srv.ListenAndServe()
 }
}

package routes

import (
 "context"
 "errors"
 "fmt"
 "log/slog"

 "github.com/go-chi/chi/v5"
)

func SetupRoutes(ctx context.Context, logger *slog.Logger, router chi.Router) (cleanup func() error, err error) {

 cleanup = func() error {
  return errors.Join()
 }

 if err := errors.Join(
  setupIndexRoute(router),
 ); err != nil {
  return cleanup, fmt.Errorf("error setting up routes: %w", err)
 }

 return cleanup, nil
}

package routes

import (
 "net/http"

 "github.com/go-chi/chi/v5"
 "github.com/rphumulock/ds_nats_ttt/ui/pages"
)

func setupIndexRoute(router chi.Router) error {

 router.Get("/", func(w http.ResponseWriter, r *http.Request) {
  pages.Index().Render(r.Context(), w)
 })

 return nil
}

package layouts

templ Base() {
 
 
  
   
   
   
  
  
   { children... }
  
 
}

package pages

import "github.com/rphumulock/ds_nats_ttt/ui/layouts"

templ Index() {
 @layouts.Base() {
  
  

   
   
   
   

  
 }
}

# Make sure we're in our project root
$  cd $HOME/Projects/ds_nats_ttt

# Get Templ
$  go get github.com/a-h/templ

# Generate
$  templ generate .

# Get all of our dependencies
$  go mod tidy

go run ./cmd/web