Refactor cache initialization to accept CacheManagerInterface for improved cache management

Author: KaveeshaPiumini

backend/cmd/server/servicemanager.go

@@ -55,6 +55,7 @@ import (
 	"github.com/asgardeo/thunder/internal/ou"
 	"github.com/asgardeo/thunder/internal/resource"
 	"github.com/asgardeo/thunder/internal/role"
+	"github.com/asgardeo/thunder/internal/system/cache"
 	"github.com/asgardeo/thunder/internal/system/crypto/hash"
 	"github.com/asgardeo/thunder/internal/system/crypto/pki"
 	declarativeresource "github.com/asgardeo/thunder/internal/system/declarative_resource"
@@ -79,6 +80,7 @@ var observabilitySvc observability.ObservabilityServiceInterface
 // registerServices registers all the services with the provided HTTP multiplexer.
 func registerServices(mux *http.ServeMux) jwt.JWTServiceInterface {
 	logger := log.GetLogger()
+	cacheManager := cache.GetCacheManager()
 
 	// Load the server's private key for signing JWTs.
 	pkiService, err := pki.Initialize()
@@ -130,14 +132,14 @@ func registerServices(mux *http.ServeMux) jwt.JWTServiceInterface {
 
 	// Initialize user schema service
 	userSchemaService, userSchemaExporter, err := userschema.Initialize(
-		mux, ouService, ouAuthzService, consentService)
+		mux, cacheManager, ouService, ouAuthzService, consentService)
 	if err != nil {
 		logger.Fatal("Failed to initialize UserSchemaService", log.Error(err))
 	}
 	exporters = append(exporters, userSchemaExporter)
 
 	// Initialize entity service
-	entityService, err := entity.Initialize(hashService, userSchemaService, ouService)
+	entityService, err := entity.Initialize(cacheManager, hashService, userSchemaService, ouService)
 	if err != nil {
 		logger.Fatal("Failed to initialize EntityService", log.Error(err))
 	}
@@ -232,7 +234,7 @@ func registerServices(mux *http.ServeMux) jwt.JWTServiceInterface {
 	attributeCacheService := attributecache.Initialize()
 
 	// Initialize flow and executor services.
-	flowFactory, graphCache := flowcore.Initialize()
+	flowFactory, graphCache := flowcore.Initialize(cacheManager)
 	var emailClient email.EmailClientInterface
 	emailClient, err = email.Initialize()
 	if err != nil {
@@ -245,12 +247,13 @@ func registerServices(mux *http.ServeMux) jwt.JWTServiceInterface {
 		observabilitySvc, groupService, roleService, entityProvider, attributeCacheService, emailClient,
 		templateService, oauthAuthnService, oidcAuthnService, githubAuthnService, googleAuthnService)
 
-	flowMgtService, flowMgtExporter, err := flowmgt.Initialize(mux, mcpServer, flowFactory, execRegistry, graphCache)
+	flowMgtService, flowMgtExporter, err := flowmgt.Initialize(
+		mux, mcpServer, cacheManager, flowFactory, execRegistry, graphCache)
 	if err != nil {
 		logger.Fatal("Failed to initialize FlowMgtService", log.Error(err))
 	}
 	exporters = append(exporters, flowMgtExporter)
-	certservice, err := cert.Initialize()
+	certservice, err := cert.Initialize(cacheManager)
 	if err != nil {
 		logger.Fatal("Failed to initialize CertificateService", log.Error(err))
 	}
@@ -270,8 +273,8 @@ func registerServices(mux *http.ServeMux) jwt.JWTServiceInterface {
 
 	// TODO: Remove entityService dependency after finalizing declarative resource loading pattern
 	applicationService, applicationExporter, err := application.Initialize(
-		mux, mcpServer, entityProvider, entityService, ouService, certservice, flowMgtService, themeMgtService,
-		layoutMgtService, userSchemaService, consentService)
+		mux, mcpServer, cacheManager, entityProvider, entityService, ouService, certservice,
+		flowMgtService, themeMgtService, layoutMgtService, userSchemaService, consentService)
 	if err != nil {
 		logger.Fatal("Failed to initialize ApplicationService", log.Error(err))
 	}

backend/internal/application/cache_backed_store.go

@@ -34,10 +34,12 @@ type cachedBackedApplicationStore struct {
 }
 
 // newCachedBackedApplicationStore creates a new cache-backed application store.
-func newCachedBackedApplicationStore(store applicationStoreInterface) applicationStoreInterface {
+func newCachedBackedApplicationStore(store applicationStoreInterface,
+	appByIDCache cache.CacheInterface[*applicationConfigDAO],
+	oauthAppCache cache.CacheInterface[*oauthConfigDAO]) applicationStoreInterface {
 	return &cachedBackedApplicationStore{
-		AppByIDCache:  cache.GetCache[*applicationConfigDAO]("ApplicationByIDCache"),
-		OAuthAppCache: cache.GetCache[*oauthConfigDAO]("OAuthAppByEntityIDCache"),
+		AppByIDCache:  appByIDCache,
+		OAuthAppCache: oauthAppCache,
 		Store:         store,
 	}
 }

backend/internal/application/init.go

@@ -32,6 +32,7 @@ import (
 	"github.com/asgardeo/thunder/internal/entityprovider"
 	flowmgt "github.com/asgardeo/thunder/internal/flow/mgt"
 	oupkg "github.com/asgardeo/thunder/internal/ou"
+	"github.com/asgardeo/thunder/internal/system/cache"
 	serverconst "github.com/asgardeo/thunder/internal/system/constants"
 	declarativeresource "github.com/asgardeo/thunder/internal/system/declarative_resource"
 	"github.com/asgardeo/thunder/internal/system/middleware"
@@ -43,6 +44,7 @@ import (
 func Initialize(
 	mux *http.ServeMux,
 	mcpServer *mcp.Server,
+	cacheManager cache.CacheManagerInterface,
 	entityProvider entityprovider.EntityProviderInterface,
 	entityService entity.EntityServiceInterface,
 	ouService oupkg.OrganizationUnitServiceInterface,
@@ -54,7 +56,7 @@ func Initialize(
 	consentService consent.ConsentServiceInterface,
 ) (ApplicationServiceInterface, declarativeresource.ResourceExporter, error) {
 	// Step 1: Initialize store and transactioner based on store mode
-	appStore, transactioner, err := initializeStore()
+	appStore, transactioner, err := initializeStore(cacheManager)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -123,7 +125,8 @@ func Initialize(
 // - If application.store is not specified, falls back to global declarative_resources.enabled:
 //   - If declarative_resources.enabled = true: behaves as IMMUTABLE mode
 //   - If declarative_resources.enabled = false: behaves as MUTABLE mode
-func initializeStore() (applicationStoreInterface, transaction.Transactioner, error) {
+func initializeStore(cacheManager cache.CacheManagerInterface) (
+	applicationStoreInterface, transaction.Transactioner, error) {
 	storeMode := getApplicationStoreMode()
 
 	switch storeMode {
@@ -144,7 +147,9 @@ func initializeStore() (applicationStoreInterface, transaction.Transactioner, er
 		if err != nil {
 			return nil, nil, err
 		}
-		return newCachedBackedApplicationStore(dbStore), transactioner, nil
+		appByIDCache := cache.GetCache[*applicationConfigDAO](cacheManager, "ApplicationByIDCache")
+		oauthAppCache := cache.GetCache[*oauthConfigDAO](cacheManager, "OAuthAppByEntityIDCache")
+		return newCachedBackedApplicationStore(dbStore, appByIDCache, oauthAppCache), transactioner, nil
 	}
 }
 

backend/internal/application/init_test.go

@@ -29,6 +29,7 @@ import (
 	"github.com/asgardeo/thunder/internal/application/model"
 	"github.com/asgardeo/thunder/internal/cert"
 	oauth2const "github.com/asgardeo/thunder/internal/oauth/oauth2/constants"
+	"github.com/asgardeo/thunder/internal/system/cache"
 	"github.com/asgardeo/thunder/internal/system/config"
 	dbmodel "github.com/asgardeo/thunder/internal/system/database/model"
 	"github.com/asgardeo/thunder/internal/system/database/provider"
@@ -156,6 +157,7 @@ func (suite *InitTestSuite) TestInitialize_WithDeclarativeResourcesDisabled() {
 	service, _, err := Initialize(
 		mux,
 		nil,
+		cache.GetCacheManager(),
 		nil, // entityProvider - not needed for this test
 		mockEntityService,
 		nil, // ouService - not needed for this test
@@ -202,6 +204,7 @@ func (suite *InitTestSuite) TestInitialize_WithMCPServer() {
 	service, _, err := Initialize(
 		mux,
 		mcpServer,
+		cache.GetCacheManager(),
 		nil, // entityProvider - not needed for this test
 		mockEntityService,
 		nil, // ouService - not needed for this test
@@ -605,6 +608,7 @@ func TestInitialize_Standalone(t *testing.T) {
 	service, _, err := Initialize(
 		mux,
 		nil,
+		cache.GetCacheManager(),
 		nil, // entityProvider - not needed for this test
 		mockEntityService,
 		nil, // ouService - not needed for this test
@@ -660,6 +664,7 @@ func TestInitialize_WithDeclarativeResources_Standalone(t *testing.T) {
 	service, _, err := Initialize(
 		mux,
 		nil,
+		cache.GetCacheManager(),
 		nil, // entityProvider - not needed for this test
 		mockEntityService,
 		nil, // ouService - not needed for this test

backend/internal/cert/cache_backed_store.go

@@ -36,10 +36,12 @@ type cacheBackedStore struct {
 }
 
 // NewCachedBackedCertificateStore creates a new instance of CachedBackedCertificateStore.
-func newCachedBackedCertificateStore() certificateStoreInterface {
+func newCachedBackedCertificateStore(
+	certByIDCache cache.CacheInterface[*Certificate],
+	certByReferenceCache cache.CacheInterface[*Certificate]) certificateStoreInterface {
 	return &cacheBackedStore{
-		certByIDCache:        cache.GetCache[*Certificate]("CertificateByIDCache"),
-		certByReferenceCache: cache.GetCache[*Certificate]("CertificateByReferenceCache"),
+		certByIDCache:        certByIDCache,
+		certByReferenceCache: certByReferenceCache,
 		store:                newCertificateStore(),
 	}
 }

backend/internal/cert/init.go

@@ -19,17 +19,20 @@
 package cert
 
 import (
+	"github.com/asgardeo/thunder/internal/system/cache"
 	"github.com/asgardeo/thunder/internal/system/database/provider"
 )
 
 // Initialize initializes and returns the certificate service.
-func Initialize() (CertificateServiceInterface, error) {
+func Initialize(cacheManager cache.CacheManagerInterface) (CertificateServiceInterface, error) {
 	dbProvider := provider.GetDBProvider()
 	txn, err := dbProvider.GetConfigDBTransactioner()
 	if err != nil {
 		return nil, err
 	}
-	certStore := newCachedBackedCertificateStore()
+	certByIDCache := cache.GetCache[*Certificate](cacheManager, "CertificateByIDCache")
+	certByReferenceCache := cache.GetCache[*Certificate](cacheManager, "CertificateByReferenceCache")
+	certStore := newCachedBackedCertificateStore(certByIDCache, certByReferenceCache)
 	certService := newCertificateService(certStore, txn)
 	return certService, nil
 }

backend/internal/entity/cache_backed_store.go

@@ -35,9 +35,10 @@ type cacheBackedEntityStore struct {
 }
 
 // newCacheBackedEntityStore creates a cache-backed wrapper around the given store.
-func newCacheBackedEntityStore(store entityStoreInterface) entityStoreInterface {
+func newCacheBackedEntityStore(store entityStoreInterface,
+	entityByIDCache cache.CacheInterface[*Entity]) entityStoreInterface {
 	return &cacheBackedEntityStore{
-		entityByIDCache: cache.GetCache[*Entity]("EntityByIDCache"),
+		entityByIDCache: entityByIDCache,
 		store:           store,
 		logger: log.GetLogger().With(
 			log.String(log.LoggerKeyComponentName, "CacheBackedEntityStore")),

backend/internal/entity/init.go

@@ -20,6 +20,7 @@ package entity
 
 import (
 	"github.com/asgardeo/thunder/internal/ou"
+	"github.com/asgardeo/thunder/internal/system/cache"
 	"github.com/asgardeo/thunder/internal/system/crypto/hash"
 	"github.com/asgardeo/thunder/internal/system/transaction"
 	"github.com/asgardeo/thunder/internal/userschema"
@@ -30,11 +31,12 @@ import (
 // Declarative resources are loaded on demand by consumer packages (e.g. user, application)
 // based on their own store mode configuration.
 func Initialize(
+	cacheManager cache.CacheManagerInterface,
 	hashService hash.HashServiceInterface,
 	userSchemaService userschema.UserSchemaServiceInterface,
 	ouService ou.OrganizationUnitServiceInterface,
 ) (EntityServiceInterface, error) {
-	store, transactioner, err := initializeStore()
+	store, transactioner, err := initializeStore(cacheManager)
 	if err != nil {
 		return nil, err
 	}
@@ -44,12 +46,14 @@ func Initialize(
 }
 
 // initializeStore always creates a composite store (DB + in-memory file store).
-func initializeStore() (entityStoreInterface, transaction.Transactioner, error) {
+func initializeStore(cacheManager cache.CacheManagerInterface) (
+	entityStoreInterface, transaction.Transactioner, error) {
 	fileStore := newEntityFileBasedStore()
 	dbStore, transactioner, err := newEntityDBStore()
 	if err != nil {
 		return nil, nil, err
 	}
-	cacheBackedEntityStore := newCacheBackedEntityStore(dbStore)
+	entityByIDCache := cache.GetCache[*Entity](cacheManager, "EntityByIDCache")
+	cacheBackedEntityStore := newCacheBackedEntityStore(dbStore, entityByIDCache)
 	return newEntityCompositeStore(fileStore, cacheBackedEntityStore), transactioner, nil
 }

backend/internal/flow/core/graph_cache.go

@@ -38,9 +38,9 @@ type graphCache struct {
 }
 
 // newGraphCache creates a new in-memory cache instance of graphCache.
-func newGraphCache() GraphCacheInterface {
+func newGraphCache(c cache.CacheInterface[*graph]) GraphCacheInterface {
 	return &graphCache{
-		cache: cache.GetInMemoryCache[*graph]("FlowGraphCache"),
+		cache: c,
 	}
 }
 

backend/internal/flow/core/init.go

@@ -19,9 +19,12 @@
 // Package core provides the core structs for flow management and execution.
 package core
 
+import "github.com/asgardeo/thunder/internal/system/cache"
+
 // Initialize initializes the core flow package
-func Initialize() (FlowFactoryInterface, GraphCacheInterface) {
+func Initialize(cacheManager cache.CacheManagerInterface) (FlowFactoryInterface, GraphCacheInterface) {
 	flowFactory := newFlowFactory()
-	graphCache := newGraphCache()
+	graphCacheInst := cache.GetInMemoryCache[*graph](cacheManager, "FlowGraphCache")
+	graphCache := newGraphCache(graphCacheInst)
 	return flowFactory, graphCache
 }