feat(repository): cache engine-relevant methods

internal/repository/cache/cache.go

@@ -0,0 +1,33 @@
+package cache
+
+import (
+	"time"
+
+	"github.com/hashicorp/golang-lru/v2/expirable"
+)
+
+type Cacheable interface {
+	// Set sets a value in the cache with the given key
+	Set(key string, value interface{})
+
+	// Get gets a value from the cache with the given key
+	Get(key string) (interface{}, bool)
+}
+
+type Cache struct {
+	cache *expirable.LRU[string, interface{}]
+}
+
+func (c *Cache) Set(key string, value interface{}) {
+	c.cache.Add(key, value)
+}
+
+func (c *Cache) Get(key string) (interface{}, bool) {
+	return c.cache.Get(key)
+}
+
+func New() *Cache {
+	return &Cache{
+		cache: expirable.NewLRU[string, interface{}](512, nil, time.Minute*1),
+	}
+}

internal/repository/prisma/api_token.go

@@ -5,26 +5,40 @@ import (
 	"time"
 
 	"github.com/hatchet-dev/hatchet/internal/repository"
+	"github.com/hatchet-dev/hatchet/internal/repository/cache"
 	"github.com/hatchet-dev/hatchet/internal/repository/prisma/db"
 	"github.com/hatchet-dev/hatchet/internal/validator"
 )
 
 type apiTokenRepository struct {
 	client *db.PrismaClient
 	v      validator.Validator
+	cache  cache.Cacheable
 }
 
-func NewAPITokenRepository(client *db.PrismaClient, v validator.Validator) repository.APITokenRepository {
+func NewAPITokenRepository(client *db.PrismaClient, v validator.Validator, cache cache.Cacheable) repository.APITokenRepository {
 	return &apiTokenRepository{
 		client: client,
 		v:      v,
+		cache:  cache,
 	}
 }
 
 func (a *apiTokenRepository) GetAPITokenById(id string) (*db.APITokenModel, error) {
-	return a.client.APIToken.FindUnique(
+	if v, ok := a.cache.Get(id); ok {
+		return v.(*db.APITokenModel), nil
+	}
+
+	token, err := a.client.APIToken.FindUnique(
 		db.APIToken.ID.Equals(id),
 	).Exec(context.Background())
+	if err != nil {
+		return nil, err
+	}
+
+	a.cache.Set(id, token)
+
+	return token, nil
 }
 
 func (a *apiTokenRepository) CreateAPIToken(opts *repository.CreateAPITokenOpts) (*db.APITokenModel, error) {

internal/repository/prisma/repository.go

@@ -5,6 +5,7 @@ import (
 	"github.com/rs/zerolog"
 
 	"github.com/hatchet-dev/hatchet/internal/repository"
+	"github.com/hatchet-dev/hatchet/internal/repository/cache"
 	"github.com/hatchet-dev/hatchet/internal/repository/prisma/db"
 	"github.com/hatchet-dev/hatchet/internal/validator"
 )
@@ -66,11 +67,13 @@ func NewPrismaRepository(client *db.PrismaClient, pool *pgxpool.Pool, fs ...Pris
 	newLogger := opts.l.With().Str("service", "database").Logger()
 	opts.l = &newLogger
 
+	c := cache.New()
+
 	return &prismaRepository{
-		apiToken:       NewAPITokenRepository(client, opts.v),
+		apiToken:       NewAPITokenRepository(client, opts.v, c),
 		event:          NewEventRepository(client, pool, opts.v, opts.l),
 		log:            NewLogRepository(client, pool, opts.v, opts.l),
-		tenant:         NewTenantRepository(client, opts.v),
+		tenant:         NewTenantRepository(client, opts.v, c),
 		tenantInvite:   NewTenantInviteRepository(client, opts.v),
 		workflow:       NewWorkflowRepository(client, pool, opts.v, opts.l),
 		workflowRun:    NewWorkflowRunRepository(client, pool, opts.v, opts.l),

internal/repository/prisma/tenant.go

@@ -4,19 +4,22 @@ import (
 	"context"
 
 	"github.com/hatchet-dev/hatchet/internal/repository"
+	"github.com/hatchet-dev/hatchet/internal/repository/cache"
 	"github.com/hatchet-dev/hatchet/internal/repository/prisma/db"
 	"github.com/hatchet-dev/hatchet/internal/validator"
 )
 
 type tenantRepository struct {
 	client *db.PrismaClient
 	v      validator.Validator
+	cache  cache.Cacheable
 }
 
-func NewTenantRepository(client *db.PrismaClient, v validator.Validator) repository.TenantRepository {
+func NewTenantRepository(client *db.PrismaClient, v validator.Validator, cache cache.Cacheable) repository.TenantRepository {
 	return &tenantRepository{
 		client: client,
 		v:      v,
+		cache:  cache,
 	}
 }
 
@@ -37,9 +40,21 @@ func (r *tenantRepository) ListTenants() ([]db.TenantModel, error) {
 }
 
 func (r *tenantRepository) GetTenantByID(id string) (*db.TenantModel, error) {
-	return r.client.Tenant.FindUnique(
+	if v, ok := r.cache.Get(id); ok {
+		return v.(*db.TenantModel), nil
+	}
+
+	tenant, err := r.client.Tenant.FindUnique(
 		db.Tenant.ID.Equals(id),
 	).Exec(context.Background())
+
+	if err != nil {
+		return nil, err
+	}
+
+	r.cache.Set(id, tenant)
+
+	return tenant, nil
 }
 
 func (r *tenantRepository) GetTenantBySlug(slug string) (*db.TenantModel, error) {