cache

func Bind ¶ added in v1.13.0

func Bind[T any](name string, build func() *Config, opts ...BindOption) nexus.Option

Bind wires a named cache connection declaratively — the cache counterpart to nexus.Database / pubsub.Broker. It lives here (not in the nexus root) so that importing the root package does NOT drag Redis, gocache, and Prometheus into the build; an app pays for those only when it actually calls cache.Bind. T must embed *Manager:

type SessionCache struct{ *cache.Manager }

nexus.Run(cfg,
    cache.Bind[SessionCache]("session", func() *cache.Config {
        c := cache.NewConfig()
        c.RedisHost = nexus.Get[string]("cache.redis.host")
        c.RedisPort = nexus.Get[string]("cache.redis.port")
        return c
    }, cache.WithDefault()),
)

build() runs in the fx constructor (so nexus.Get resolves), the framework Start()s the manager on boot and Stop()s it on shutdown, and the connection is registered as a dashboard resource via the manager's AsResource (which reports Redis-vs-memory health). Handlers inject *SessionCache. T not embedding *Manager panics at wiring time.

func ManifestEnv ¶

func ManifestEnv() []manifest.EnvVar

ManifestEnv lists the env vars this package's NewConfig reads. Apps that include cache.Module in their nexus.Run options should also add nexus.DeclareEnvList(cache.ManifestEnv()) so the deploy-time manifest reflects the cache's configuration surface — otherwise an orchestration platform reading the manifest won't know REDIS_HOST / REDIS_PORT / REDIS_PASSWORD / APP_ENV are required.

Two design notes:

1. We expose a slice rather than implementing manifest.EnvProvider on *Manager. EnvProvider would only be detected once *Manager enters the graph, but in print mode we want declarations visible WITHOUT firing constructors (Manager's constructor dials Redis). Static slices are side-effect-free by definition.

2. We expose ManifestService too — the cache's logical sidecar ("redis"). Both are returned together as a convenience but kept as separate functions so an app that, say, uses an external managed Redis (no provisioned sidecar needed) can include ManifestEnv() but skip ManifestService().

func ManifestService ¶

func ManifestService() manifest.ServiceNeed

ManifestService describes the Redis sidecar this package would like the orchestration platform to provision. Optional=true reflects that the cache layer degrades to in-memory when Redis is absent — the platform can skip provisioning in dev environments where that trade-off is acceptable.

func NewMetricsStore ¶ added in v1.13.0

func NewMetricsStore(mgr *Manager) metrics.Store

NewMetricsStore returns a metrics.Store backed by a nexus *Manager — the in-memory path uses go-cache, and the Redis path persists counters so multi-replica deploys see aggregated totals. It lives in package cache (not metrics) so that extension/metrics — which the framework core imports for the default in-process store — never drags Redis/gocache into the build. Opt in explicitly:

Config.Stores.Metrics = cache.NewMetricsStore(mgr)

Semantics: counters are best-effort. Every Record does a read-modify- write against the cache under the endpoint key, so concurrent writers (or replicas in Redis mode) can step on each other's increments. For a dashboard view that's fine; for exact counts under contention point the app at a Prometheus collector instead. Keys are namespaced under "nexus.metrics." with a 24h TTL.

func RegisterRedis ¶ added in v1.13.0

func RegisterRedis(f func(*Manager) RedisSupervisor)

RegisterRedis installs the Redis supervisor factory. Called from extension/cache/redis's init(), so a blank import is all an app needs to enable Redis (the database/sql driver pattern). Not part of the surface apps call directly.