cache

func Get ¶

func Get[T any](ctx context.Context, c *Cache, key string) (v T, ok bool, err error)

Get reads key into T; ok is false when the key is missing or expired.

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/AlexGalhardo/vukem/cache"
)

func main() {
	ctx := context.Background()
	c := cache.New(cache.NewMemory(1000), "")

	_ = c.Put(ctx, "greeting", "hello", time.Minute)

	v, ok, err := cache.Get[string](ctx, c, "greeting")
	fmt.Println(v, ok, err)

	_, ok, _ = cache.Get[string](ctx, c, "missing")
	fmt.Println(ok)
}

Output:
hello true <nil>
false

func Layers ¶ added in v0.26.0

func Layers(st Store) iter.Seq[Store]

Layers yields st and then each store underneath it, following wrappers (metrics, tracing) that expose the store they wrap with an Unwrap() Store method. It stops at a store without Unwrap, at nil, or after 32 stores, whichever comes first; callers looking for a capability treat a chain cut by the limit as not having it.

func Migrations ¶ added in v0.29.0

func Migrations(table string) []schema.Migration

Migrations returns the migration that creates the cache table (the default when table is empty), so an app can manage it with vukem migrate instead of leaving it to the boot-time CreateTable. The statements are the ones CreateTable runs, which stays as the fallback for apps that do not register it.

On a database where the table already exists (the store created it before the app opted in) the migration records itself and changes nothing; Down drops the table.

func Remember ¶

func Remember[T any](ctx context.Context, c *Cache, key string, ttl time.Duration,
	fn func(ctx context.Context) (T, error),
) (T, error)

Remember returns the cached value or computes it with fn and stores it for ttl. Concurrent misses for the same key in this process run fn once (singleflight), so an expired hot key does not stampede the database.

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/AlexGalhardo/vukem/cache"
)

type user struct {
	ID   int64
	Name string
}

func main() {
	ctx := context.Background()
	c := cache.New(cache.NewMemory(1000), "app:")

	loads := 0
	load := func(context.Context) (user, error) {
		loads++
		return user{ID: 42, Name: "Ada"}, nil
	}

	first, _ := cache.Remember(ctx, c, "user:42", time.Hour, load)
	second, _ := cache.Remember(ctx, c, "user:42", time.Hour, load)
	fmt.Println(first.Name, second.Name, "loads:", loads)
}

Output:
Ada Ada loads: 1

func Shared ¶ added in v0.26.0

func Shared(st Store) bool

Shared reports whether st is shared by every server of the app. The first store in Layers that implements Sharer answers; when none does (an undeclared store, nil, or an Unwrap chain longer than the limit), st is not shared, so a check that needs a shared store fails closed instead of trusting an unknown one.