feat: add configurable dashboard path and consolidate tests

Add DASHBOARD_PATH env var to support flexible dashboard locations in tests

Author: l-you

Makefile

@@ -1,4 +1,8 @@
 prod-example:
 	cd docker && docker-compose --env-file .env.example -f docker-compose.yml up --build
+
 test:
-	cd ./server && make test && cd ../dashboard && bun run test
+	@echo "Running dashboard linting and type checking..."
+	cd ./dashboard && bun run lint && bun run tsc
+	@echo "\nRunning Go unit tests..."
+	cd ./server && DASHBOARD_PATH=../dashboard/dist go test -v ./... --count=2

server/e2e/e2e_test.go

@@ -21,8 +21,9 @@ import (
 func testConfig() *config.Config {
 	return &config.Config{
 		Server: config.ServerConfig{
-			Host: "127.0.0.1",
-			Port: "0",
+			Host:          "127.0.0.1",
+			Port:          "0",
+			DashboardPath: "", // Empty for tests - dashboard not required
 		},
 		Database: config.DatabaseConfig{
 			Driver: "sqlite",

server/internal/config/config.go

@@ -18,9 +18,10 @@ type Config struct {
 }
 
 type ServerConfig struct {
-	Host     string
-	Port     string
-	BasePath string // Base path for all routes (e.g., "/app" or "/")
+	Host          string
+	Port          string
+	BasePath      string // Base path for all routes (e.g., "/app" or "/")
+	DashboardPath string // Path to dashboard files (defaults to "dashboard")
 }
 
 type DatabaseConfig struct {
@@ -49,9 +50,10 @@ func Load() *Config {
 	}
 	return &Config{
 		Server: ServerConfig{
-			Host:     getEnv("SERVER_HOST", "0.0.0.0"),
-			Port:     getEnv("SERVER_PORT", "8080"),
-			BasePath: basePath,
+			Host:          getEnv("SERVER_HOST", "0.0.0.0"),
+			Port:          getEnv("SERVER_PORT", "8080"),
+			BasePath:      basePath,
+			DashboardPath: getEnv("DASHBOARD_PATH", "dashboard"),
 		},
 		Database: DatabaseConfig{
 			Driver:   getEnv("DB_DRIVER", "sqlite"),

server/internal/dashboard/dashboard.go

@@ -9,22 +9,21 @@ import (
 	"strings"
 )
 
-// StaticDir is the directory containing built dashboard files (set at build time)
-const StaticDir = "dashboard"
-
 // Config holds the runtime configuration for the dashboard
 type Config struct {
-	BasePath   string
-	APIUrl     string
-	GraphQLUrl string
+	BasePath      string
+	APIUrl        string
+	GraphQLUrl    string
+	DashboardPath string // Path to dashboard files (defaults to "dashboard")
 }
 
 // DefaultConfig returns the default configuration
 func DefaultConfig() Config {
 	return Config{
-		BasePath:   "/",
-		APIUrl:     "/api",
-		GraphQLUrl: "/graphql",
+		BasePath:      "/",
+		APIUrl:        "/api",
+		GraphQLUrl:    "/graphql",
+		DashboardPath: "dashboard",
 	}
 }
 
@@ -39,6 +38,11 @@ window.__ENV__ = {
 
 // Handler returns an http.Handler that serves the dashboard with the given config
 func Handler(cfg Config) http.Handler {
+	// Set default dashboard path if not provided
+	if cfg.DashboardPath == "" {
+		cfg.DashboardPath = "dashboard"
+	}
+
 	// Normalize base path - keep empty string for root, or ensure it starts with / and has no trailing /
 	if cfg.BasePath != "" {
 		if !strings.HasPrefix(cfg.BasePath, "/") {
@@ -51,10 +55,14 @@ func Handler(cfg Config) http.Handler {
 	tmpl := template.Must(template.New("config.js").Parse(configJSTemplate))
 
 	// Read index.html and prepare it with base path replacements
-	indexPath := filepath.Join(StaticDir, "index.html")
+	indexPath := filepath.Join(cfg.DashboardPath, "index.html")
 	indexHTML, err := os.ReadFile(indexPath)
 	if err != nil {
-		panic("Failed to read index.html: " + err.Error())
+		// Return a minimal handler that serves a placeholder
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusServiceUnavailable)
+			w.Write([]byte("Dashboard not available"))
+		})
 	}
 	// Replace {{BASE_PATH}} placeholder with actual base path
 	indexContent := string(indexHTML)
@@ -68,7 +76,7 @@ func Handler(cfg Config) http.Handler {
 	}
 
 	// Create file server for static files
-	fileServer := http.FileServer(http.Dir(StaticDir))
+	fileServer := http.FileServer(http.Dir(cfg.DashboardPath))
 
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		// Serve dynamically generated config.js
@@ -88,7 +96,7 @@ func Handler(cfg Config) http.Handler {
 		}
 
 		// Try to check if file exists on disk
-		filePath := filepath.Join(StaticDir, filepath.Clean(urlPath))
+		filePath := filepath.Join(cfg.DashboardPath, filepath.Clean(urlPath))
 		if info, err := os.Stat(filePath); err == nil && !info.IsDir() {
 			// Special handling for index.html - serve with BASE_PATH replacements
 			if urlPath == "index.html" {

server/internal/handlers/health_handlers.go

@@ -5,15 +5,16 @@ import (
 	"os"
 	"path/filepath"
 
-	"github.com/lovely-eye/server/internal/dashboard"
 	"github.com/uptrace/bun"
 )
 type HealthHandler struct {
-	db *bun.DB
+	db            *bun.DB
+	dashboardPath string
 }
-func NewHealthHandler(db *bun.DB) *HealthHandler {
+func NewHealthHandler(db *bun.DB, dashboardPath string) *HealthHandler {
 	return &HealthHandler{
-		db: db,
+		db:            db,
+		dashboardPath: dashboardPath,
 	}
 }
 func (h *HealthHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
@@ -26,11 +27,13 @@ func (h *HealthHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 
-		// Check dashboard files exist
-		if _, err := os.Stat(filepath.Join(dashboard.StaticDir, "index.html")); err != nil {
-			w.WriteHeader(http.StatusServiceUnavailable)
-			w.Write([]byte(`{"status":"unhealthy","error":"dashboard files not found"}`))
-			return
+		// Check dashboard files exist (skip check if dashboard path is empty for tests)
+		if h.dashboardPath != "" {
+			if _, err := os.Stat(filepath.Join(h.dashboardPath, "index.html")); err != nil {
+				w.WriteHeader(http.StatusServiceUnavailable)
+				w.Write([]byte(`{"status":"unhealthy","error":"dashboard files not found"}`))
+				return
+			}
 		}
 
 		w.WriteHeader(http.StatusOK)

server/internal/server/server.go

@@ -120,16 +120,17 @@ func New(cfg *config.Config) (*Server, error) {
 		w.Header().Set("Access-Control-Allow-Origin", "*")
 		w.Write(trackerJS)
 	})
-	hh := handlers.NewHealthHandler(db)
+	hh := handlers.NewHealthHandler(db, cfg.Server.DashboardPath)
 
 	// Health check (always at root for load balancers)
 	mux.Handle("GET /health", hh)
 
 	// Setup dashboard handler with runtime config
 	dashboardCfg := dashboard.Config{
-		BasePath:   basePath,
-		APIUrl:     basePath + "/api",
-		GraphQLUrl: basePath + "/graphql",
+		BasePath:      basePath,
+		APIUrl:        basePath + "/api",
+		GraphQLUrl:    basePath + "/graphql",
+		DashboardPath: cfg.Server.DashboardPath,
 	}
 	dashboardHandler := dashboard.Handler(dashboardCfg)