Serving a static dir, but with a custom handler for missed files?

[radiosilence]

I would like to use echoserver to serve up an SPA with frontend routing. This means the root public dir should be served with e.Static, and that any 404 URLs must be instead sent to my custom index.html handler (uses templating to inject runtime environment variables). What is the idiomatic way to do this? I have a solution that involves filepath.Walk and to create routes.

Currently my entire code is:

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"path/filepath"
	"strings"
	"text/template"

	"github.com/labstack/echo/v4"
	"github.com/labstack/echo/v4/middleware"
)

type Template struct {
	templates *template.Template
}

type TemplateData struct {
	Env         map[string]string `json:"env"`
	Json        string            `json:"json"`
	EscapedJson string            `json:"escapedJson"`
}

func (t *Template) Render(w io.Writer, name string, data any, c echo.Context) error {
	fmt.Printf("%+v\n", data)
	return t.templates.ExecuteTemplate(w, name, data)
}

func getAppEnv() map[string]string {
	prefix := getEnv("CONFIG_PREFIX", "VITE_")
	data := make(map[string]string)
	for _, env := range os.Environ() {
		parts := strings.Split(env, "=")
		key := parts[0]
		value := strings.Join(parts[1:], "=")
		if strings.HasPrefix(key, prefix) {
			data[strings.Replace(key, prefix, "", 1)] = value
		}
	}
	return data
}

var appEnv = getAppEnv()

func Index(c echo.Context) error {
	jsonString, err := json.Marshal(appEnv)
	if err != nil {
		return err
	}
	return c.Render(http.StatusOK, "index.html", &TemplateData{
		Env:         appEnv,
		Json:        string(jsonString),
		EscapedJson: strings.Replace(string(jsonString), "\"", "\\\"", -1),
	})
}

func getEnv(name string, fallback string) string {
	value, exists := os.LookupEnv(name)
	if !exists {
		value = fallback
	}
	return value
}

func main() {
	e := echo.New()
	addr := ":" + getEnv("PORT", "80")

	if os.Getenv("SPA_MODE") == "1" {
		t := &Template{
			templates: template.Must(template.ParseFiles("public/index.html")),
		}
		e.Renderer = t
		e.GET("/*", Index)
	}

	filepath.Walk("public", func(path string, info os.FileInfo, err error) error {
		if info.IsDir() {
			return nil
		}
		e.GET(strings.Replace(path, "public", "", 1), func(c echo.Context) error {
			return c.File(path)
		})
		return nil
	})

	e.Use(middleware.Gzip())
	e.Use(middleware.Logger())

	e.Logger.Fatal(e.Start(addr))
}

Which seems to work, but wondering if there's an easier way than re-implementing e.Static.

[aldas]

Probably not. Most of the middleware code deals with options that you probably do not need/is not related to your requirements. So rolling your own stupidly simple implementation (in a good way) is not wrong way to go.

Have you looked into Static middleware? https://echo.labstack.com/docs/middleware/static#example-2 You index seems to be static (based on envs which do not change during runtime) so you could use static middleware with HTML5 option.

p.s. You could probably create own struct that implements filesystem interface and when static middleware tries to open index page it renders it from template and other files are read from actual (os)filesystem.