Applying `middleware.StaticWithConfig` to `echo.Group` always results in 404

[ivan-avalos]

I'm applying the StaticWithConfig middleware to a group and it always returns 404, am I doing anything wrong? It seems to work if I apply directly to e instead of to the group.

e.Pre(middleware.Rewrite(map[string]string{"/": "/app"}))

app := e.Group("/app")
app.Use(middleware.StaticWithConfig(middleware.StaticConfig{
	IgnoreBase: true,
	HTML5:      true,
	Root:      "../client/out",
	Index:      "index.html",
}))

auth := e.Group("/api")
// ...

$ ls -la ../client/out
avalos@macmini server % ls -la ../client/out
...
-rw-r--r--   1 avalos  staff  11914 Mar 21 23:22 index.html
...

Thanks in advance.

[its-ernest]

@ivan-avalos , This looks like a misuse or perhaps not syncing with the latest echo v5. Check out my result others this is likely to be closed by the maintainers

you need to actually register a route in the group for the middleware to trigger. I tried double-checking the error with sample runner, see:

package main

import (
	"fmt"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"

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

func main() {
	e := echo.New()

	// this creates a temporary static file
	tmpDir, _ := os.MkdirTemp("", "echo-static")
	defer os.RemoveAll(tmpDir)

	filePath := filepath.Join(tmpDir, "test.txt")
	os.WriteFile(filePath, []byte("hello echo v5"), 0644)

	// setup a group with Static Middleware
	g := e.Group("/assets")
	g.Use(middleware.StaticWithConfig(middleware.StaticConfig{
		Root: tmpDir,
	}))
	// define a route after group
       // you can use `/*` instead of `/test.txt` only
	g.GET("/test.txt", func(c *echo.Context) error {
		return nil
	})

	// test the request
	req := httptest.NewRequest(http.MethodGet, "/assets/test.txt", nil)
	rec := httptest.NewRecorder()

	e.ServeHTTP(rec, req)

	fmt.Printf("Status Code: %d\n", rec.Code)
	fmt.Printf("Body: %s\n", rec.Body.String())

	if rec.Code == http.StatusNotFound {
		fmt.Println("Bug Reproduced: Group static middleware failed with 404")
	} else {
		fmt.Println("Success: Static file served correctly")
	}
}

Result:

$ go run montent.go               
Status Code: 200
Body: 
Success: Static file served correctly

If there is some further buggy behavior, explain further, or you can show a sample runner of yours that fails here so we debug.

[its-ernest]

YOU WILL DEFINITELY FIND IT HELPFUL

The above comment is valid config, but it makes the middleware misbehave(like null body)
because echo v5 has a concise method: g.Static()
Simple to use, it returns something.

package main

import (
	"fmt"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"

	"github.com/labstack/echo/v5"
)

func main() {
	e := echo.New()

	// this creates a temporary static file
	tmpDir, _ := os.MkdirTemp("", "echo-static")
	defer os.RemoveAll(tmpDir)

	filePath := filepath.Join(tmpDir, "test.txt")
	os.WriteFile(filePath, []byte("hello echo v5"), 0644)

	// setup a group with Static Middleware
	g := e.Group("/assets")
	g.Static("/", tmpDir)

	// test the request
	req := httptest.NewRequest(http.MethodGet, "/assets/test.txt", nil)
	rec := httptest.NewRecorder()

	e.ServeHTTP(rec, req)

	fmt.Printf("Status Code: %d\n", rec.Code)
	fmt.Printf("Body: %s\n", rec.Body.String())

	if rec.Code == http.StatusNotFound {
		fmt.Println("Bug Reproduced: Group static middleware failed with 404")
	} else {
		fmt.Println("Success: Static file served correctly")
	}
}

$ go run montent.go
Status Code: 200
Body: hello echo v5
Success: Static file served correctly

[ivan-avalos]

Thank you, @its-ernest!

I tried both of your solutions combined and it works now! This should be written in the documentation in more detail, as it was not clear to me that a middleware in a group without routes will never be triggered at all. Another option would be to have a e.StaticWithConf so I can pass a config option to the route, because otherwise the middleware is the only way to achieve this.

[aldas]

@ivan-avalos If you have time, you could help us by improving website. Group documentation is located here https://github.com/labstack/echox/blob/master/website/docs/guide/routing.md#group

[its-ernest]

Thank you, @its-ernest!

I tried both of your solutions combined and it works now! This should be written in the documentation in more detail, as it was not clear to me that a middleware in a group without routes will never be triggered at all. Another option would be to have a e.StaticWithConf so I can pass a config option to the route, because otherwise the middleware is the only way to achieve this.

Optionally if you want maximum control by using StaticWithConfig and also read files from your disk, you have to use virtual filesystem(os.DirFS) instead of directly reading the folder on disk to improve security.
Also you have to register a dummy route on the e.Group('/assets') that you create.

• Note: note to check the response in the dummy route if the size is > 0. Else your /assets route will always return 200 even if it doesn't find any file. Example is below:

package main

import (
	"fmt"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"

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

func main() {
	e := echo.New()

	// create temp dir in current folder
	tmpDir, _ := os.MkdirTemp(".", "static-")
	// use actual existing directory in production
	//staticDir := "static"

	defer os.RemoveAll(tmpDir)

	// create the test file
	os.WriteFile(filepath.Join(tmpDir, "test.txt"), []byte("hello echo v5"), 0644)

	// setup the Group
	g := e.Group("/assets")

	// attach the middleware to the GROUP specifically
	// this makes 'IgnoreBase' redundant because the group prefix is handled by the router
	g.Use(middleware.StaticWithConfig(middleware.StaticConfig{
		Filesystem: os.DirFS(tmpDir), // or staticDir in production
		Root:       "",               // look in the root of the DirFS filesystem
		IgnoreBase: true,
	}))

	// stills need a dummy route for the group to be active in the router
	g.GET("/*", func(c *echo.Context) error {
		// c.Response returns an interface
		// cast the interface to the concrete *echo.Response struct
		res := c.Response().(*echo.Response)

		// check if the middleware already wrote to the response
		if res.Committed || res.Size > 0 {
			return nil
		}

		// otherwise, return explicitly 404
		return echo.ErrNotFound
	})

	// test the request
	req := httptest.NewRequest(http.MethodGet, "/assets/test.txt", nil)
	rec := httptest.NewRecorder()

	e.ServeHTTP(rec, req)

	fmt.Printf("Status Code: %d\n", rec.Code)
	fmt.Printf("Body: %s\n", rec.Body.String())

	if rec.Code == http.StatusOK {
		fmt.Println("Success: Static file served correctly")
	} else {
		fmt.Printf("Failed with Status: %d\n", rec.Code)
	}
}

$ go run montent.go
Status Code: 200
Body: hello echo v5
Success: Static file served correctly

This is already in the Static middleware docs, just that it lacks examples on using StaticWithConfig with a static folder on your actual disk.
I would take time to add sample example of it to the docs before the end of March

[aldas]

@its-ernest, did you LLMed that answer? I think the handler is little bit too complex. If the static middleware does not find the file by using path value the handler is executed and any error returned from it will be shown to the client.

echo/middleware/static.go

Lines 240 to 250 in 675712d

	file, err := currentFS.Open(filePath)
	if err != nil {
	if !isIgnorableOpenFileError(err) {
	return err
	}
	// file with that path did not exist, so we continue down in middleware/handler chain, hoping that we end up in
	// handler that is meant to handle this request
	err = next(c)
	if err == nil {
	return nil
	}

So following example is maybe cleaner solution

package main

import (
	"os"

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

func main() {
	e := echo.New()

	g := e.Group("/assets")

	g.Use(middleware.StaticWithConfig(middleware.StaticConfig{
		Filesystem: os.DirFS("./assets/"), // use the current directory as the root
	}))

	// stills need a dummy route for the group to be active in the router
	g.GET("/*", func(c *echo.Context) error {
		return echo.ErrNotFound
	})

	if err := e.Start(":8080"); err != nil {
		e.Logger.Error("failed to start server", "error", err)
	}
}

[aldas]

and I will improve static middleware docs on website and add note about handler
https://github.com/labstack/echox/blob/master/website/docs/middleware/static.md