data layer

data-layer/api/internal/cache/cache.go

@@ -0,0 +1,52 @@
+// Package cache wraps rueidis with the semantic-key convention used by the
+// analytics service. Keys follow cache:<kind>:<workspace_id>:<hash(params)>
+// so a workspace can be invalidated without scanning unrelated entries.
+package cache
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/redis/rueidis"
+)
+
+type Cache struct {
+	client rueidis.Client
+}
+
+func New(client rueidis.Client) *Cache { return &Cache{client: client} }
+
+// Key builds a deterministic cache key for the given (kind, workspace, params).
+// Params must JSON-serialize stably -- use a struct or a sorted map.
+func Key(kind, workspaceID string, params any) (string, error) {
+	raw, err := json.Marshal(params)
+	if err != nil {
+		return "", fmt.Errorf("cache key marshal: %w", err)
+	}
+	sum := sha256.Sum256(raw)
+	return fmt.Sprintf("cache:%s:%s:%s", kind, workspaceID, hex.EncodeToString(sum[:16])), nil
+}
+
+// Get returns (value, true) on hit and (nil, false) on miss. Any redis error
+// is treated as a miss -- the caller falls through to the underlying source.
+func (c *Cache) Get(ctx context.Context, key string) ([]byte, bool) {
+	res := c.client.Do(ctx, c.client.B().Get().Key(key).Build())
+	b, err := res.AsBytes()
+	if err != nil {
+		if errors.Is(err, rueidis.Nil) {
+			return nil, false
+		}
+		return nil, false
+	}
+	return b, true
+}
+
+// Set writes the value with a TTL.
+func (c *Cache) Set(ctx context.Context, key string, value []byte, ttl time.Duration) error {
+	return c.client.Do(ctx, c.client.B().Set().Key(key).Value(rueidis.BinaryString(value)).Ex(ttl).Build()).Error()
+}