How to Add Redis to an Echo App

// shop/shop.go
package shop

import (
	"crypto/rand"
	"encoding/hex"
	"errors"
	"net/http"
	"time"

	"encore.dev/storage/cache"
	"github.com/labstack/echo/v4"
	"github.com/labstack/echo/v4/middleware"
)

// One Redis cluster for the service: in-memory with `encore run`,
// ElastiCache on AWS and Memorystore on GCP when deployed.
var cluster = cache.NewCluster("shop-cache", cache.ClusterConfig{
	EvictionPolicy: cache.AllKeysLRU,
})

type Receipt struct {
	OrderID     string `json:"order_id"`
	AmountCents int64  `json:"amount_cents"`
	Status      string `json:"status"`
}

// Finished responses, replayed for 24 hours when a client retries with the same key.
var idemResponses = cache.NewStructKeyspace[string, Receipt](cluster, cache.KeyspaceConfig{
	KeyPattern:    "idem/response/:key",
	DefaultExpiry: cache.ExpireIn(24 * time.Hour),
})

// Lock lease is longer than the order+charge work. The value is a random
// owner token so release deletes only this request's lock.
var idemLocks = cache.NewStringKeyspace[string](cluster, cache.KeyspaceConfig{
	KeyPattern:    "idem/lock/:key",
	DefaultExpiry: cache.ExpireIn(2 * time.Minute),
})

// Product IDs each user opened, newest first.
var recentlyViewed = cache.NewListKeyspace[string, string](cluster, cache.KeyspaceConfig{
	KeyPattern:    "recent/:key",
	DefaultExpiry: cache.ExpireIn(30 * 24 * time.Hour),
})

//encore:service
type Service struct {
	e *echo.Echo
}

func initService() (*Service, error) {
	e := echo.New()
	e.Use(middleware.Recover())
	e.POST("/orders", createOrder)
	e.GET("/products/:id", viewProduct)
	e.GET("/me/recently-viewed", listRecent)
	return &Service{e: e}, nil
}

// Fallback sends every request that no Encore endpoint matches to Echo.
//
//encore:api public raw path=/!fallback
func (s *Service) Fallback(w http.ResponseWriter, req *http.Request) {
	s.e.ServeHTTP(w, req)
}

func createOrder(c echo.Context) error {
	ctx := c.Request().Context()
	key := c.Request().Header.Get("Idempotency-Key")
	if key == "" {
		return echo.NewHTTPError(http.StatusBadRequest, "Idempotency-Key header is required")
	}

	// A retry of a finished request gets the original response back.
	if r, err := idemResponses.Get(ctx, key); err == nil {
		c.Response().Header().Set("Idempotent-Replayed", "true")
		return c.JSON(http.StatusCreated, r)
	} else if !errors.Is(err, cache.Miss) {
		return err
	}

	// A retry that arrives while the first request is still running is rejected.
	token := newID()
	if err := idemLocks.SetIfNotExists(ctx, key, token); errors.Is(err, cache.KeyExists) {
		return echo.NewHTTPError(http.StatusConflict, "a request with this key is in progress")
	} else if err != nil {
		return err
	}
	defer func() {
		held, err := idemLocks.Get(ctx, key)
		if err == nil && held == token {
			_, _ = idemLocks.Delete(ctx, key)
		}
	}()

	var in struct {
		AmountCents int64 `json:"amount_cents"`
	}
	if err := c.Bind(&in); err != nil || in.AmountCents <= 0 {
		return echo.NewHTTPError(http.StatusBadRequest, "amount_cents must be positive")
	}

	// Write the order to the database and charge the customer here.
	r := Receipt{OrderID: newID(), AmountCents: in.AmountCents, Status: "created"}
	if err := idemResponses.Set(ctx, key, r); err != nil {
		return err
	}
	return c.JSON(http.StatusCreated, r)
}

func viewProduct(c echo.Context) error {
	ctx := c.Request().Context()
	id := c.Param("id")
	if user := userID(c); user != "" {
		// Move the product to the front and keep the 20 newest.
		_, _ = recentlyViewed.RemoveAll(ctx, user, id)
		_, _ = recentlyViewed.PushLeft(ctx, user, id)
		_ = recentlyViewed.Trim(ctx, user, 0, 19)
	}
	return c.JSON(http.StatusOK, map[string]string{"id": id})
}

func listRecent(c echo.Context) error {
	user := userID(c)
	if user == "" {
		return echo.NewHTTPError(http.StatusUnauthorized)
	}
	ids, err := recentlyViewed.GetRange(c.Request().Context(), user, 0, 19)
	if err != nil && !errors.Is(err, cache.Miss) {
		return err
	}
	return c.JSON(http.StatusOK, map[string][]string{"product_ids": ids})
}

// userID reads the ID your authentication middleware stored on the context.
func userID(c echo.Context) string {
	id, _ := c.Get("userID").(string)
	return id
}

func newID() string {
	b := make([]byte, 8)
	_, _ = rand.Read(b)
	return "ord_" + hex.EncodeToString(b)
}

var rdb = redis.NewClient(&redis.Options{
	Addr:      os.Getenv("REDIS_ADDR"),
	Username:  os.Getenv("REDIS_USERNAME"),
	Password:  os.Getenv("REDIS_PASSWORD"),
	TLSConfig: tlsConfig(), // nil locally, TLS 1.2+ against ElastiCache
})

func acquireLock(ctx context.Context, key, token string) (bool, error) {
	return rdb.SetNX(ctx, "idem:lock:"+key, token, 2*time.Minute).Result()
}

func releaseLock(ctx context.Context, key, token string) {
	val, err := rdb.Get(ctx, "idem:lock:"+key).Result()
	if err == nil && val == token {
		_ = rdb.Del(ctx, "idem:lock:"+key).Err()
	}
}

func trackView(ctx context.Context, user, productID string) error {
	k := "recent:" + user
	_, err := rdb.TxPipelined(ctx, func(p redis.Pipeliner) error {
		p.LRem(ctx, k, 0, productID)
		p.LPush(ctx, k, productID)
		p.LTrim(ctx, k, 0, 19)
		p.Expire(ctx, k, 30*24*time.Hour)
		return nil
	})
	return err
}