wip

README.md

@@ -90,7 +90,6 @@
 * [Logging](#logging)
 * [Roadmap](#roadmap)
 * [Credits](#credits)
-* [Similar Projects](#similar-projects)
 
 ## Introduction
 
@@ -1188,8 +1187,3 @@ Thank you to all of the following amazing projects for making this possible.
 - [testify](https://github.com/stretchr/testify)
 - [validator](https://github.com/go-playground/validator)
 - [viper](https://github.com/spf13/viper)
-
-## Similar Projects
-
-- [go-templ-htmx-templ](https://github.com/HoneySinghDev/go-templ-htmx-template)
-- [go-webly](https://github.com/gowebly/gowebly)

pkg/handlers/router.go

@@ -42,7 +42,6 @@ func BuildRouter(c *services.Container) error {
 		}),
 		middleware.Session(sessions.NewCookieStore([]byte(c.Config.App.EncryptionKey))),
 		middleware.LoadAuthenticatedUser(c.Auth),
-		middleware.ServeCachedPage(c.TemplateRenderer),
 		echomw.CSRFWithConfig(echomw.CSRFConfig{
 			TokenLookup: "form:csrf",
 		}),

pkg/middleware/cache.go

@@ -1,64 +1,12 @@
 package middleware
 
 import (
-	"errors"
 	"fmt"
-	"net/http"
 	"time"
 
 	"github.com/labstack/echo/v4"
-
-	"git.grosinger.net/tgrosinger/saasitone/pkg/context"
-	"git.grosinger.net/tgrosinger/saasitone/pkg/log"
-	"git.grosinger.net/tgrosinger/saasitone/pkg/services"
 )
 
-// ServeCachedPage attempts to load a page from the cache by matching on the complete request URL
-// If a page is cached for the requested URL, it will be served here and the request terminated.
-// Any request made by an authenticated user or that is not a GET will be skipped.
-func ServeCachedPage(t *services.TemplateRenderer) echo.MiddlewareFunc {
-	return func(next echo.HandlerFunc) echo.HandlerFunc {
-		return func(ctx echo.Context) error {
-			// Skip non GET requests
-			if ctx.Request().Method != http.MethodGet {
-				return next(ctx)
-			}
-
-			// Skip if the user is authenticated
-			if ctx.Get(context.AuthenticatedUserKey) != nil {
-				return next(ctx)
-			}
-
-			// Attempt to load from cache
-			page, err := t.GetCachedPage(ctx, ctx.Request().URL.String())
-			if err != nil {
-				switch {
-				case errors.Is(err, services.ErrCacheMiss):
-				case context.IsCanceledError(err):
-					return nil
-				default:
-					log.Ctx(ctx).Error("failed getting cached page",
-						"error", err,
-					)
-				}
-
-				return next(ctx)
-			}
-
-			// Set any headers
-			if page.Headers != nil {
-				for k, v := range page.Headers {
-					ctx.Response().Header().Set(k, v)
-				}
-			}
-
-			log.Ctx(ctx).Debug("serving cached page")
-
-			return ctx.HTMLBlob(page.StatusCode, page.HTML)
-		}
-	}
-}
-
 // CacheControl sets a Cache-Control header with a given max age
 func CacheControl(maxAge time.Duration) echo.MiddlewareFunc {
 	return func(next echo.HandlerFunc) echo.HandlerFunc {

pkg/middleware/cache_test.go

@@ -1,56 +1,14 @@
 package middleware
 
 import (
-	"net/http"
 	"testing"
 	"time"
 
-	"github.com/a-h/templ"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 
-	"git.grosinger.net/tgrosinger/saasitone/pkg/page"
 	"git.grosinger.net/tgrosinger/saasitone/pkg/tests"
-	"git.grosinger.net/tgrosinger/saasitone/templ/pages"
-	"git.grosinger.net/tgrosinger/saasitone/templ/layouts"
-	"git.grosinger.net/tgrosinger/saasitone/templates"
 )
 
-func TestServeCachedPage(t *testing.T) {
-	// Cache a page
-	ctx, rec := tests.NewContext(c.Web, "/cache")
-	p := page.New(ctx)
-	p.Name = templates.PageHome
-	p.Cache.Enabled = true
-	p.Cache.Expiration = time.Minute
-	p.StatusCode = http.StatusCreated
-	p.Headers["a"] = "b"
-	p.Headers["c"] = "d"
-	p.LayoutComponent = func(content templ.Component) templ.Component {
-		return layouts.HTMX(p, content)
-	}
-	err := c.TemplateRenderer.RenderPageTempl(ctx, p, pages.Cache(p, &pages.CacheForm{}, nil))
-	output := rec.Body.Bytes()
-	require.NoError(t, err)
-
-	// Request the URL of the cached page
-	ctx, rec = tests.NewContext(c.Web, "/cache")
-	err = tests.ExecuteMiddleware(ctx, ServeCachedPage(c.TemplateRenderer))
-	assert.NoError(t, err)
-	assert.Equal(t, p.StatusCode, ctx.Response().Status)
-	assert.Equal(t, p.Headers["a"], ctx.Response().Header().Get("a"))
-	assert.Equal(t, p.Headers["c"], ctx.Response().Header().Get("c"))
-	assert.Equal(t, output, rec.Body.Bytes())
-
-	// Login and try again
-	tests.InitSession(ctx)
-	err = c.Auth.Login(ctx, usr.ID)
-	require.NoError(t, err)
-	_ = tests.ExecuteMiddleware(ctx, LoadAuthenticatedUser(c.Auth))
-	err = tests.ExecuteMiddleware(ctx, ServeCachedPage(c.TemplateRenderer))
-	assert.Nil(t, err)
-}
-
 func TestCacheControl(t *testing.T) {
 	ctx, _ := tests.NewContext(c.Web, "/")
 	_ = tests.ExecuteMiddleware(ctx, CacheControl(time.Second*5))

pkg/services/template_renderer.go

@@ -13,8 +13,6 @@ import (
 	"github.com/labstack/echo/v4"
 
 	"git.grosinger.net/tgrosinger/saasitone/config"
-	"git.grosinger.net/tgrosinger/saasitone/pkg/context"
-	"git.grosinger.net/tgrosinger/saasitone/pkg/log"
 	"git.grosinger.net/tgrosinger/saasitone/pkg/page"
 	"git.grosinger.net/tgrosinger/saasitone/templates"
 )
@@ -137,70 +135,9 @@ func (t *TemplateRenderer) RenderPageTempl(ctx echo.Context, page page.Page, con
 		page.HTMX.Response.Apply(ctx)
 	}
 
-	// Cache this page, if caching was enabled
-	t.cachePage(ctx, page, &buf)
 	return ctx.HTMLBlob(ctx.Response().Status, buf.Bytes())
 }
 
-// cachePage caches the HTML for a given Page if the Page has caching enabled
-func (t *TemplateRenderer) cachePage(ctx echo.Context, page page.Page, html *bytes.Buffer) {
-	if !page.Cache.Enabled || page.IsAuth {
-		return
-	}
-
-	// If no expiration time was provided, default to the configuration value
-	if page.Cache.Expiration == 0 {
-		page.Cache.Expiration = t.config.Cache.Expiration.Page
-	}
-
-	// Extract the headers
-	headers := make(map[string]string)
-	for k, v := range ctx.Response().Header() {
-		headers[k] = v[0]
-	}
-
-	// The request URL is used as the cache key so the middleware can serve the
-	// cached page on matching requests
-	key := ctx.Request().URL.String()
-	cp := &CachedPage{
-		URL:        key,
-		HTML:       html.Bytes(),
-		Headers:    headers,
-		StatusCode: ctx.Response().Status,
-	}
-
-	err := t.cache.
-		Set().
-		Group(cachedPageGroup).
-		Key(key).
-		Tags(page.Cache.Tags...).
-		Expiration(page.Cache.Expiration).
-		Data(cp).
-		Save(ctx.Request().Context())
-
-	switch {
-	case err == nil:
-		log.Ctx(ctx).Debug("cached page")
-	case !context.IsCanceledError(err):
-		log.Ctx(ctx).Error("failed to cache page",
-			"error", err,
-		)
-	}
-}
-
-// GetCachedPage attempts to fetch a cached page for a given URL
-func (t *TemplateRenderer) GetCachedPage(ctx echo.Context, url string) (*CachedPage, error) {
-	p, err := t.cache.
-		Get().
-		Group(cachedPageGroup).
-		Key(url).
-		Fetch(ctx.Request().Context())
-	if err != nil {
-		return nil, err
-	}
-
-	return p.(*CachedPage), nil
-}
 // getCacheKey gets a cache key for a given group and ID
 func (t *TemplateRenderer) getCacheKey(group, key string) string {
 	if group != "" {