coder · bryphe-coder · Feb 9, 2022 · Feb 5, 2022 · Feb 5, 2022 · Feb 5, 2022
diff --git a/coderd/coderd.go b/coderd/coderd.go
@@ -109,7 +109,7 @@ func New(options *Options) http.Handler {
 			r.Get("/serve", api.provisionerDaemonsServe)
 		})
 	})
-	r.NotFound(site.Handler().ServeHTTP)
+	r.NotFound(site.Handler(options.Logger).ServeHTTP)
 	return r
 }
 

diff --git a/go.mod b/go.mod
@@ -98,6 +98,7 @@ require (
 	github.com/pion/udp v0.1.1 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/psanford/memfs v0.0.0-20210214183328-a001468d78ef // indirect
 	github.com/sirupsen/logrus v1.8.1 // indirect
 	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/xeipuuv/gojsonpointer v0.0.0-20190905194746-02993c407bfb // indirect

diff --git a/go.sum b/go.sum
@@ -1087,6 +1087,8 @@ github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4O
 github.com/prometheus/procfs v0.2.0/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 github.com/prometheus/procfs v0.6.0/go.mod h1:cz+aTbrPOrUb4q7XlbU9ygM+/jj0fzG6c1xBZuNvfVA=
 github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
+github.com/psanford/memfs v0.0.0-20210214183328-a001468d78ef h1:NKxTG6GVGbfMXc2mIk+KphcH6hagbVXhcFkbTgYleTI=
+github.com/psanford/memfs v0.0.0-20210214183328-a001468d78ef/go.mod h1:tcaRap0jS3eifrEEllL6ZMd9dg8IlDpi2S1oARrQ+NI=
 github.com/remyoudompheng/bigfft v0.0.0-20190728182440-6a916e37a237/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=

diff --git a/nextrouter/nextrouter.go b/nextrouter/nextrouter.go
@@ -0,0 +1,225 @@
+package nextrouter
+
+import (
+	"bytes"
+	"context"
+	"html/template"
+	"io/fs"
+	"net/http"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/go-chi/chi/v5"
+
+	"cdr.dev/slog"
+)
+
+// Options for configuring a nextrouter
+type Options struct {
+	Logger           slog.Logger
+	TemplateDataFunc TemplateDataFunc
+}
+
+// TemplateDataFunc is a function that lets the consumer of `nextrouter`
+// inject arbitrary template parameters, based on the request. This is useful
+// if the Request object is carrying CSRF tokens, session tokens, etc -
+// they can be emitted in the page.
+type TemplateDataFunc func(*http.Request) interface{}
+
+// Handler returns an HTTP handler for serving a next-based static site
+// This handler respects NextJS-based routing rules:
+// https://nextjs.org/docs/routing/dynamic-routes
+//
+// 1) If a file is of the form `[org]`, it's a dynamic route for a single-parameter
+// 2) If a file is of the form `[[...any]]`, it's a dynamic route for any parameters
+func Handler(fileSystem fs.FS, options *Options) http.Handler {
+	if options == nil {
+		options = &Options{
+			Logger:           slog.Logger{},
+			TemplateDataFunc: nil,
+		}
+	}
+	router := chi.NewRouter()
+
+	// Build up a router that matches NextJS routing rules, for HTML files
+	buildRouter(router, fileSystem, *options)
+
+	// Fallback to static file server for non-HTML files
+	// Non-HTML files don't have special routing rules, so we can just leverage
+	// the built-in http.FileServer for it.
+	fileHandler := http.FileServer(http.FS(fileSystem))
+	router.NotFound(fileHandler.ServeHTTP)
+
+	// Finally, if there is a 404.html available, serve that
+	serve404IfAvailable(fileSystem, router, *options)
+
+	return router
+}
+
+// buildRouter recursively traverses the file-system, building routes
+// as appropriate for respecting NextJS dynamic rules.
+func buildRouter(rtr chi.Router, fileSystem fs.FS, options Options) {
+	files, err := fs.ReadDir(fileSystem, ".")
+	if err != nil {
+		options.Logger.Warn(context.Background(), "Provided filesystem is empty; unable to build routes")
+		return
+	}
+
+	// Loop through everything in the current directory...
+	for _, file := range files {
+		name := file.Name()
+
+		// ...if it's a directory, create a sub-route by
+		// recursively calling `buildRouter`
+		if file.IsDir() {
+			sub, err := fs.Sub(fileSystem, name)
+			if err != nil {
+				options.Logger.Error(context.Background(), "Unable to call fs.Sub on directory", slog.F("directory_name", name))
+				continue
+			}
+
+			// In the special case where the folder is dynamic,
+			// like `[org]`, we can convert to a chi-style dynamic route
+			// (which uses `{` instead of `[`)
+			routeName := name
+			if isDynamicRoute(name) {
+				routeName = "{dynamic}"
+			}
+
+			options.Logger.Info(context.Background(), "Adding route", slog.F("name", name), slog.F("routeName", routeName))
+			rtr.Route("/"+routeName, func(r chi.Router) {
+				buildRouter(r, sub, options)
+			})
+		} else {
+			// ...otherwise, if it's a file - serve it up!
+			serveFile(rtr, fileSystem, name, options)
+		}
+	}
+}
+
+// serveFile is responsible for serving up HTML files in our next router
+// It handles various special cases, like trailing-slashes or handling routes w/o the .html suffix.
+func serveFile(router chi.Router, fileSystem fs.FS, fileName string, options Options) {
+	// We only handle .html files for now
+	ext := filepath.Ext(fileName)
+	if ext != ".html" {
+		return
+	}
+
+	options.Logger.Debug(context.Background(), "Reading file", slog.F("fileName", fileName))
+
+	data, err := fs.ReadFile(fileSystem, fileName)
+	if err != nil {
+		options.Logger.Error(context.Background(), "Unable to read file", slog.F("fileName", fileName))
+		return
+	}
+
+	// Create a template from the data - we can inject custom parameters like CSRF here
+	tpls, err := template.New(fileName).Parse(string(data))
+	if err != nil {
+		options.Logger.Error(context.Background(), "Unable to create template for file", slog.F("fileName", fileName))
+		return
+	}
+
+	handler := func(writer http.ResponseWriter, request *http.Request) {
+		var buf bytes.Buffer
+
+		// See if there are any template parameters we need to inject!
+		// Things like CSRF tokens, etc...
+		//templateData := struct{}{}
+		var templateData interface{}
+		templateData = nil
+		if options.TemplateDataFunc != nil {
+			templateData = options.TemplateDataFunc(request)
+		}
+
+		options.Logger.Debug(context.Background(), "Applying template parameters", slog.F("fileName", fileName), slog.F("templateData", templateData))
+		err := tpls.ExecuteTemplate(&buf, fileName, templateData)
+
+		if err != nil {
+			options.Logger.Error(request.Context(), "Error executing template", slog.F("template_parameters", templateData))
+			http.Error(writer, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+			return
+		}
+
+		http.ServeContent(writer, request, fileName, time.Time{}, bytes.NewReader(buf.Bytes()))
+	}
+
+	fileNameWithoutExtension := removeFileExtension(fileName)
+
+	// Handle the `[[...any]]` catch-all case
+	if isCatchAllRoute(fileNameWithoutExtension) {
+		options.Logger.Info(context.Background(), "Registering catch-all route", slog.F("fileName", fileName))
+		router.NotFound(handler)
+		return
+	}
+
+	// Handle the `[org]` dynamic route case
+	if isDynamicRoute(fileNameWithoutExtension) {
+		options.Logger.Info(context.Background(), "Registering dynamic route", slog.F("fileName", fileName))
+		router.Get("/{dynamic}", handler)
+		return
+	}
+
+	// Handle the basic file cases
+	// Directly accessing a file, ie `/providers.html`
+	router.Get("/"+fileName, handler)
+	// Accessing a file without an extension, ie `/providers`
+	router.Get("/"+fileNameWithoutExtension, handler)
+
+	// Special case: '/' should serve index.html
+	if fileName == "index.html" {
+		router.Get("/", handler)
+	} else {
+		// Otherwise, handling the trailing slash case -
+		// for examples, `providers.html` should serve `/providers/`
+		router.Get("/"+fileNameWithoutExtension+"/", handler)
+	}
+}
+
+func serve404IfAvailable(fileSystem fs.FS, router chi.Router, options Options) {
+	// Get the file contents
+	fileBytes, err := fs.ReadFile(fileSystem, "404.html")
+	if err != nil {
+		// An error is expected if the file doesn't exist
+		return
+	}
+
+	router.NotFound(func(writer http.ResponseWriter, request *http.Request) {
+		writer.WriteHeader(http.StatusNotFound)
+		_, err = writer.Write(fileBytes)
+		if err != nil {
+			options.Logger.Error(request.Context(), "Unable to write bytes for 404")
+			return
+		}
+	})
+}
+
+// isDynamicRoute returns true if the file is a NextJS dynamic route, like `[orgs]`
+// Returns false if the file is not a dynamic route, or if it is a catch-all route (`[[...any]]`)
+func isDynamicRoute(fileName string) bool {
+	fileWithoutExtension := removeFileExtension(fileName)
+
+	// Assuming ASCII encoding - `len` in go works on bytes
+	byteLen := len(fileWithoutExtension)
+	if byteLen < 2 {
+		return false
+	}
+
+	return fileWithoutExtension[0] == '[' && fileWithoutExtension[1] != '[' && fileWithoutExtension[byteLen-1] == ']'
+}
+
+// isCatchAllRoute returns true if the file is a catch-all route, like `[[...any]]`
+// Return false otherwise
+func isCatchAllRoute(fileName string) bool {
+	fileWithoutExtension := removeFileExtension(fileName)
+	ret := strings.HasPrefix(fileWithoutExtension, "[[.")
+	return ret
+}
+
+// removeFileExtension removes the extension from a file
+// For example, removeFileExtension("index.html") would return "index"
+func removeFileExtension(fileName string) string {
+	return strings.TrimSuffix(fileName, filepath.Ext(fileName))
+}